Close some tracked follow-ups

Julien Couvreur · Julien Couvreur · commit 2c5cde5376d1 · 2025-10-01T03:57:47.000-07:00
diff --git a/src/Compilers/CSharp/Portable/Binder/WithUsingNamespacesAndTypesBinder.cs b/src/Compilers/CSharp/Portable/Binder/WithUsingNamespacesAndTypesBinder.cs
@@ -133,7 +133,6 @@ internal override void GetExtensionDeclarations(ArrayBuilder<NamedTypeSymbol> ex
         {
             Debug.Assert(extensions.Count == 0);
 
-            // Tracked by https://github.com/dotnet/roslyn/issues/79440 : using directives, test this flag (see TestUnusedExtensionMarksImportsAsUsed)
             bool callerIsSemanticModel = originalBinder.IsSemanticModelBinder;
 
             // We need to avoid collecting multiple candidates for an extension declaration imported both through a namespace and a static class
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -1181,7 +1181,6 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                                                             });
                             }
 
-                            // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, Ensure we are not messing up relative order of events for extension members (with relation to events for enclosing types, etc.)
                             _compilation.EventQueue.TryEnqueue(new SymbolDeclaredCompilationEvent(
                                 _compilation, methodSymbol, semanticModelWithCachedBoundNodes));
                         }
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/MethodSymbolAdapter.cs
@@ -310,7 +310,6 @@ Cci.ITypeDefinition Cci.ITypeDefinitionMember.ContainingTypeDefinition
                     return synthesizedGlobalMethod.ContainingPrivateImplementationDetailsType;
                 }
 
-                // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation?
                 if (AdaptedMethodSymbol is SynthesizedExtensionMarker marker)
                 {
                     return ((SourceMemberContainerTypeSymbol)AdaptedMethodSymbol.ContainingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingMarkerType(marker);
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PropertySymbolAdapter.cs
@@ -221,7 +221,6 @@ ITypeDefinition ITypeDefinitionMember.ContainingTypeDefinition
             {
                 CheckDefinitionInvariant();
 
-                // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation?
                 if (AdaptedPropertySymbol.GetIsNewExtensionMember())
                 {
                     var containingType = AdaptedPropertySymbol.ContainingType;
@@ -249,7 +248,6 @@ ITypeReference ITypeMemberReference.GetContainingType(EmitContext context)
         {
             CheckDefinitionInvariant();
 
-            // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation in MethodSymbolAdapter?
             if (AdaptedPropertySymbol.GetIsNewExtensionMember())
             {
                 var containingType = AdaptedPropertySymbol.ContainingType;
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Internal.Generated.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 using Roslyn.Utilities;
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Main.Generated.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 using Roslyn.Utilities;
diff --git a/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/CSharpSyntaxGenerator/CSharpSyntaxGenerator.SourceGenerator/Syntax.xml.Syntax.Generated.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.Syntax.InternalSyntax;
 using Roslyn.Utilities;
@@ -13766,8 +13767,12 @@ public sealed partial class ParameterSyntax : BaseParameterSyntax
     internal ParameterSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position)
       : base(green, parent, position)
     {
+        Validate();
     }
 
+    [Conditional("DEBUG")]
+    private partial void Validate();
+
     /// <summary>Gets the attribute declaration list.</summary>
     public override SyntaxList<AttributeListSyntax> AttributeLists => new SyntaxList<AttributeListSyntax>(GetRed(ref this.attributeLists, 0));
 
diff --git a/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs b/src/Compilers/CSharp/Portable/Syntax/ParameterSyntax.cs
@@ -13,5 +13,13 @@ internal bool IsArgList
                 return this.Type == null && this.Identifier.ContextualKind() == SyntaxKind.ArgListKeyword;
             }
         }
+
+        private partial void Validate()
+        {
+            if (Type is null && Identifier.IsKind(SyntaxKind.None))
+            {
+                throw new System.NotSupportedException();
+            }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml
@@ -4342,7 +4342,7 @@
     </Field>
     <Field Name="Type" Type="TypeSyntax" Optional="true"/>
   </AbstractNode>
-  <Node Name="ParameterSyntax" Base="BaseParameterSyntax" SkipConvenienceFactories="true">
+  <Node Name="ParameterSyntax" Base="BaseParameterSyntax" SkipConvenienceFactories="true" HasValidate="true"> 
     <TypeComment>
       <summary>Parameter syntax.</summary>
     </TypeComment>
@@ -4357,9 +4357,8 @@
         <summary>Gets the modifier list.</summary>
       </PropertyComment>
     </Field>
-    <Field Name="Type" Type="TypeSyntax" Optional="true" Override="true"/>
+    <Field Name="Type" Type="TypeSyntax" Optional="true" RequiredForTest="true" Override="true"/>
     <Field Name="Identifier" Type="SyntaxToken" Optional="true">
-      <!-- Tracked by https://github.com/dotnet/roslyn/issues/78961 : enforce that a ParameterSyntax cannot be created with both Type and Identifier missing -->
       <PropertyComment>
         <summary>Gets the identifier.</summary>
       </PropertyComment>
diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs
@@ -853,7 +853,6 @@ public static SyntaxKind GetBaseTypeDeclarationKind(SyntaxKind kind)
             return kind == SyntaxKind.EnumKeyword ? SyntaxKind.EnumDeclaration : GetTypeDeclarationKind(kind);
         }
 
-        // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, decide what we want for extension declaration
         public static SyntaxKind GetTypeDeclarationKind(SyntaxKind kind)
         {
             switch (kind)
@@ -866,6 +865,8 @@ public static SyntaxKind GetTypeDeclarationKind(SyntaxKind kind)
                     return SyntaxKind.InterfaceDeclaration;
                 case SyntaxKind.RecordKeyword:
                     return SyntaxKind.RecordDeclaration;
+                case SyntaxKind.ExtensionKeyword:
+                    return SyntaxKind.ExtensionBlockDeclaration;
                 default:
                     return SyntaxKind.None;
             }
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs
@@ -44430,9 +44430,6 @@ static class E
             Diagnostic(ErrorCode.ERR_MainClassNotFound).WithArguments("E.<G>$BA41CFE2B5EDAEB8C1B9062F59ED4D69").WithLocation(1, 1));
 
         AssertEx.Equal("<G>$BA41CFE2B5EDAEB8C1B9062F59ED4D69", comp.GetTypeByMetadataName("E").GetTypeMembers().Single().ExtensionGroupingName);
-
-        // Tracked by https://github.com/dotnet/roslyn/issues/78968 : we should find the unspeakable nested type
-        Assert.Null(comp.GetTypeByMetadataName("E+<G>$BA41CFE2B5EDAEB8C1B9062F59ED4D69"));
     }
 
     [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs b/src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs
@@ -33270,6 +33270,11 @@ public void M<U, V>(U u, V v)
         var method = (IMethodSymbol)model.GetSymbolInfo(memberAccess).Symbol;
         AssertEx.Equal("void E.M<T, System.Int64, System.String>(this T t, System.Int64 u, System.String v)",
             method.AssociatedExtensionImplementation.ToTestDisplayString());
+
+        // The T in associated implementation is from the extension definition
+        var t = method.AssociatedExtensionImplementation.TypeArguments[0];
+        Assert.Equal("T", t.ToTestDisplayString());
+        Assert.True(t.ContainingSymbol is INamedTypeSymbol { IsExtension: true });
     }
 
     [Fact]
@@ -33335,6 +33340,45 @@ public void M()
         AssertEx.Equal("void E<System.Int32>.M(this System.Int32 i)", constructedMethod.AssociatedExtensionImplementation.ToTestDisplayString());
     }
 
+    [Fact]
+    public void AssociatedExtensionImplementation_11()
+    {
+        // not a definition, generic extension and method, partially constructed with type parameters
+        var src = """
+public static class E
+{
+    extension<T1, T2>(T1 t1)
+    {
+        public void M<U1, U2>(T2 t2, U1 u1, U2 u2)
+        {
+            t1.M(42, u1, "");
+        }
+    }
+}
+""";
+        var comp = CreateCompilation(src);
+        comp.VerifyEmitDiagnostics();
+
+        var tree = comp.SyntaxTrees.First();
+        var model = comp.GetSemanticModel(tree);
+        var memberAccess = GetSyntax<MemberAccessExpressionSyntax>(tree, "t1.M");
+        var method = (IMethodSymbol)model.GetSymbolInfo(memberAccess).Symbol;
+        AssertEx.Equal("void E.M<T1, System.Int32, U1, System.String>(this T1 t1, System.Int32 t2, U1 u1, System.String u2)",
+            method.AssociatedExtensionImplementation.ToTestDisplayString());
+
+        // The T1 in associated implementation is from the extension definition 
+        var t1 = method.AssociatedExtensionImplementation.TypeArguments[0];
+        Assert.Equal("T1", t1.ToTestDisplayString());
+        Assert.True(t1.ContainingSymbol is INamedTypeSymbol { IsExtension: true });
+
+        // The U1 in associated implementation is from the extension member definition 
+        var u1 = method.AssociatedExtensionImplementation.TypeArguments[2];
+        Assert.Equal("U1", u1.ToTestDisplayString());
+        AssertEx.Equal("void E.<G>$B7F0343159FB3A22D67EC9801612841A<T1, T2>.M<U1, U2>(T2 t2, U1 u1, U2 u2)",
+            u1.ContainingSymbol.ToTestDisplayString());
+        Assert.True(u1.ContainingSymbol.ContainingSymbol is INamedTypeSymbol { IsExtension: true });
+    }
+
     [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/78606")]
     public void DocumentationCommentId_01()
     {
@@ -34340,5 +34384,77 @@ public static void Extension(params string[] values) { }
                 Diagnostic(ErrorCode.WRN_NullReferenceArgument, "str").WithArguments("values", "void extension(string).Extension(params string[] values)").WithLocation(7, 18)
                 );
     }
+
+    [Fact]
+    public void GetTypeByMetadataName_01()
+    {
+        string source = """
+static class E
+{
+    extension(int i)
+    {
+        public static void Main() => throw null;
+    }
+}
+""";
+        var comp = CreateCompilation(source);
+        comp.VerifyEmitDiagnostics();
+        validate(comp);
+
+        var comp2 = CreateCompilation("", references: [comp.EmitToImageReference()]);
+        comp2.VerifyEmitDiagnostics();
+        validate(comp2);
+
+        static void validate(CSharpCompilation comp)
+        {
+            var groupingName = "<G>$BA41CFE2B5EDAEB8C1B9062F59ED4D69";
+            var markerName = "<M>$F4B4FFE41AB49E80A4ECF390CF6EB372";
+
+            var extension = comp.GlobalNamespace.GetMember<NamedTypeSymbol>("E").GetTypeMembers().Single();
+            AssertEx.Equal(groupingName, extension.ExtensionGroupingName);
+            AssertEx.Equal(markerName, extension.ExtensionMarkerName);
+
+            Assert.Null(comp.GetTypeByMetadataName($"E+{groupingName}"));
+            Assert.Null(comp.GetTypeByMetadataName($"E+{groupingName}+{markerName}"));
+        }
+    }
+
+    [Fact]
+    public void ParameterSyntax_01()
+    {
+        string src = """
+static class E
+{
+    extension(int i)
+    {
+    }
+}
+""";
+        var tree = CSharpSyntaxTree.ParseText(src);
+        var parameter = tree.GetRoot().DescendantNodes().OfType<ParameterSyntax>().Single();
+        Assert.Equal("int i", parameter.ToFullString());
+
+        var withoutType = parameter.WithType(null);
+        Assert.Equal("i", withoutType.ToFullString());
+
+        var withoutIdentifer = parameter.WithIdentifier(default);
+        Assert.Equal("int ", withoutIdentifer.ToFullString());
+
+        // Type and identifier cannot both be missing
+        Assert.Throws<NotSupportedException>(() => SyntaxFactory.Parameter(identifier: default));
+        Assert.Throws<NotSupportedException>(() => withoutType.WithIdentifier(default));
+    }
+
+    [Fact]
+    public void SyntaxFacts_01()
+    {
+        Assert.Equal(SyntaxKind.ExtensionBlockDeclaration, SyntaxFacts.GetTypeDeclarationKind(SyntaxKind.ExtensionKeyword));
+        Assert.Equal(SyntaxKind.ExtensionBlockDeclaration, SyntaxFacts.GetBaseTypeDeclarationKind(SyntaxKind.ExtensionKeyword));
+        Assert.True(SyntaxFacts.IsTypeDeclaration(SyntaxKind.ExtensionBlockDeclaration));
+        Assert.Equal(SyntaxKind.ExtensionKeyword, SyntaxFacts.GetContextualKeywordKind("extension"));
+        Assert.Equal(SyntaxKind.None, SyntaxFacts.GetKeywordKind("extension"));
+        Assert.True(SyntaxFacts.IsContextualKeyword(SyntaxKind.ExtensionKeyword));
+        Assert.Equal("extension", SyntaxFacts.GetText(SyntaxKind.ExtensionKeyword));
+    }
 }
 
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/GetUnusedImportDirectivesTests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/GetUnusedImportDirectivesTests.cs
@@ -40,7 +40,7 @@ void Goo()
 
         [WorkItem(865627, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/865627")]
         [Fact]
-        public void TestUnusedExtensionMarksImportsAsUsed()
+        public void TestUnusedExtensionMarksImportsAsUsed_01()
         {
             string class1Source = @"using System;
 
@@ -102,6 +102,72 @@ static void Main(string[] args)
             model.GetDiagnostics().Verify(Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using ClassLibrary2;"));
         }
 
+        [Fact]
+        public void TestUnusedExtensionMarksImportsAsUsed_02()
+        {
+            // new extension method
+            string class1Source = """
+using System;
+
+namespace ClassLibrary1
+{
+    public class Class1
+    {
+        public void Method1(string arg1)
+        {
+            Console.WriteLine(arg1);
+        }
+    }
+}
+""";
+            var classLib1 = CreateCompilation(source: class1Source, assemblyName: "ClassLibrary1");
+
+            string class2Source = """
+using System;
+using ClassLibrary1;
+
+namespace ClassLibrary2
+{
+    public static class Class2
+    {
+        extension(Class1 arg0)
+        {
+            public void Method1(string arg1)
+            {
+                Console.Write("Erroneous: " + arg1);
+            }
+        }
+    }
+}
+""";
+            var classLib2 = CreateCompilation(source: class2Source, assemblyName: "ClassLibrary2", references: [classLib1.ToMetadataReference()]);
+
+            string consoleApplicationSource = """
+using ClassLibrary2;
+using ClassLibrary1;
+
+var instance1 = new Class1();
+instance1.Method1("Argument1");
+""";
+            var tree = Parse(consoleApplicationSource);
+            var comp = CreateCompilation(tree, [classLib1.ToMetadataReference(), classLib2.ToMetadataReference()], assemblyName: "ConsoleApplication");
+            var model = comp.GetSemanticModel(tree) as CSharpSemanticModel;
+
+            var syntax = tree.GetRoot().DescendantNodes().OfType<InvocationExpressionSyntax>().Single().Expression;
+
+            //This is the crux of the test.
+            //Without this line, with or without the fix, the model never gets pushed to evaluate extension method candidates
+            //and therefore never marked ClassLibrary2 as a used import in consoleApplication.
+            //Without the fix, this call used to result in ClassLibrary2 getting marked as used, after the fix, this call does not
+            //result in changing ClassLibrary2's used status.
+            model.GetMemberGroup(syntax);
+
+            model.GetDiagnostics().Verify(
+                // (1,1): hidden CS8019: Unnecessary using directive.
+                // using ClassLibrary2;
+                Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using ClassLibrary2;").WithLocation(1, 1));
+        }
+
         [WorkItem(747219, "DevDiv2/DevDiv")]
         [Fact]
         public void UnusedUsing747219()
diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs
@@ -605,7 +605,7 @@ private static Syntax.InternalSyntax.BracketedParameterListSyntax GenerateBracke
             => InternalSyntaxFactory.BracketedParameterList(InternalSyntaxFactory.Token(SyntaxKind.OpenBracketToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList<Syntax.InternalSyntax.ParameterSyntax>(), InternalSyntaxFactory.Token(SyntaxKind.CloseBracketToken));
 
         private static Syntax.InternalSyntax.ParameterSyntax GenerateParameter()
-            => InternalSyntaxFactory.Parameter(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), null, null, null);
+            => InternalSyntaxFactory.Parameter(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateIdentifierName(), null, null);
 
         private static Syntax.InternalSyntax.FunctionPointerParameterSyntax GenerateFunctionPointerParameter()
             => InternalSyntaxFactory.FunctionPointerParameter(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.AttributeListSyntax>(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList<Syntax.InternalSyntax.SyntaxToken>(), GenerateIdentifierName());
@@ -10955,7 +10955,7 @@ private static BracketedParameterListSyntax GenerateBracketedParameterList()
             => SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken));
 
         private static ParameterSyntax GenerateParameter()
-            => SyntaxFactory.Parameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), default(SyntaxToken), default(EqualsValueClauseSyntax));
+            => SyntaxFactory.Parameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(SyntaxToken), default(EqualsValueClauseSyntax));
 
         private static FunctionPointerParameterSyntax GenerateFunctionPointerParameter()
             => SyntaxFactory.FunctionPointerParameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName());
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/AbstractFileWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/AbstractFileWriter.cs
@@ -249,6 +249,9 @@ private static bool IsTrue(string val)
         protected static bool IsOptional(Field f)
             => IsTrue(f.Optional);
 
+        protected static bool IsOptionalForTest(Field f)
+            => IsTrue(f.Optional) && !IsTrue(f.RequiredForTest);
+
         protected static bool IsOverride(Field f)
             => IsTrue(f.Override);
 
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/Model/Field.cs b/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/Model/Field.cs
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/Model/TreeType.cs b/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/Model/TreeType.cs
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/SourceWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/SourceWriter.cs
diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/TestWriter.cs b/src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/TestWriter.cs

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,6 @@ internal override void GetExtensionDeclarations(ArrayBuilder<NamedTypeSymbol> ex`
`133`	`133`	`{`
`134`	`134`	`Debug.Assert(extensions.Count == 0);`
`135`	`135`
`136`		`- // Tracked by https://github.com/dotnet/roslyn/issues/79440 : using directives, test this flag (see TestUnusedExtensionMarksImportsAsUsed)`
`137`	`136`	`bool callerIsSemanticModel = originalBinder.IsSemanticModelBinder;`
`138`	`137`
`139`	`138`	`// We need to avoid collecting multiple candidates for an extension declaration imported both through a namespace and a static class`
Original file line number	Diff line number	Diff line change
`@@ -1181,7 +1181,6 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&`
`1181`	`1181`	`});`
`1182`	`1182`	`}`
`1183`	`1183`
`1184`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, Ensure we are not messing up relative order of events for extension members (with relation to events for enclosing types, etc.)`
`1185`	`1184`	`_compilation.EventQueue.TryEnqueue(new SymbolDeclaredCompilationEvent(`
`1186`	`1185`	`_compilation, methodSymbol, semanticModelWithCachedBoundNodes));`
`1187`	`1186`	`}`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,6 @@ Cci.ITypeDefinition Cci.ITypeDefinitionMember.ContainingTypeDefinition`
`310`	`310`	`return synthesizedGlobalMethod.ContainingPrivateImplementationDetailsType;`
`311`	`311`	`}`
`312`	`312`
`313`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation?`
`314`	`313`	`if (AdaptedMethodSymbol is SynthesizedExtensionMarker marker)`
`315`	`314`	`{`
`316`	`315`	`return ((SourceMemberContainerTypeSymbol)AdaptedMethodSymbol.ContainingType.ContainingType).GetExtensionGroupingInfo().GetCorrespondingMarkerType(marker);`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,6 @@ ITypeDefinition ITypeDefinitionMember.ContainingTypeDefinition`
`221`	`221`	`{`
`222`	`222`	`CheckDefinitionInvariant();`
`223`	`223`
`224`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation?`
`225`	`224`	`if (AdaptedPropertySymbol.GetIsNewExtensionMember())`
`226`	`225`	`{`
`227`	`226`	`var containingType = AdaptedPropertySymbol.ContainingType;`
`@@ -249,7 +248,6 @@ ITypeReference ITypeMemberReference.GetContainingType(EmitContext context)`
`249`	`248`	`{`
`250`	`249`	`CheckDefinitionInvariant();`
`251`	`250`
`252`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78827 : code quality, share logic with Cci.ITypeMemberReference.GetContainingType implementation in MethodSymbolAdapter?`
`253`	`251`	`if (AdaptedPropertySymbol.GetIsNewExtensionMember())`
`254`	`252`	`{`
`255`	`253`	`var containingType = AdaptedPropertySymbol.ContainingType;`
Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,13 @@ internal bool IsArgList`
`13`	`13`	`return this.Type == null && this.Identifier.ContextualKind() == SyntaxKind.ArgListKeyword;`
`14`	`14`	`}`
`15`	`15`	`}`
	`16`	`+`
	`17`	`+ private partial void Validate()`
	`18`	`+ {`
	`19`	`+ if (Type is null && Identifier.IsKind(SyntaxKind.None))`
	`20`	`+ {`
	`21`	`+ throw new System.NotSupportedException();`
	`22`	`+ }`
	`23`	`+ }`
`16`	`24`	`}`
`17`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -853,7 +853,6 @@ public static SyntaxKind GetBaseTypeDeclarationKind(SyntaxKind kind)`
`853`	`853`	`return kind == SyntaxKind.EnumKeyword ? SyntaxKind.EnumDeclaration : GetTypeDeclarationKind(kind);`
`854`	`854`	`}`
`855`	`855`
`856`		`- // Tracked by https://github.com/dotnet/roslyn/issues/78957 : public API, decide what we want for extension declaration`
`857`	`856`	`public static SyntaxKind GetTypeDeclarationKind(SyntaxKind kind)`
`858`	`857`	`{`
`859`	`858`	`switch (kind)`
`@@ -866,6 +865,8 @@ public static SyntaxKind GetTypeDeclarationKind(SyntaxKind kind)`
`866`	`865`	`return SyntaxKind.InterfaceDeclaration;`
`867`	`866`	`case SyntaxKind.RecordKeyword:`
`868`	`867`	`return SyntaxKind.RecordDeclaration;`
	`868`	`+ case SyntaxKind.ExtensionKeyword:`
	`869`	`+ return SyntaxKind.ExtensionBlockDeclaration;`
`869`	`870`	`default:`
`870`	`871`	`return SyntaxKind.None;`
`871`	`872`	`}`