Parse partial events and constructors

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -1171,7 +1171,7 @@
     <value>Cannot implicitly convert type '{0}' to '{1}'. An explicit conversion exists (are you missing a cast?)</value>
   </data>
   <data name="ERR_PartialMisplaced" xml:space="preserve">
-    <value>The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', or a method or property return type.</value>
+    <value>The 'partial' modifier can only appear immediately before 'class', 'record', 'struct', 'interface', 'event', an instance constructor identifier, or a method or property return type.</value>
   </data>
   <data name="ERR_ImportedCircularBase" xml:space="preserve">
     <value>Imported type '{0}' is invalid. It contains a circular base type dependency.</value>

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -1379,7 +1379,7 @@ private void ParseModifiers(SyntaxListBuilder tokens, bool forAccessors, bool fo
                 {
                     case DeclarationModifiers.Partial:
                         var nextToken = PeekToken(1);
-                        if (this.IsPartialType() || this.IsPartialMember())
+                        if (this.IsPartialType() || this.IsPartialMember(allowPartialCtor: !forTopLevelStatements))
                         {
                             // Standard legal cases.
                             modTok = ConvertToKeyword(this.EatToken());
@@ -1632,26 +1632,28 @@ private bool IsPartialType()
             return false;
         }
 
-        private bool IsPartialMember()
+        private bool IsPartialMember(bool allowPartialCtor)
         {
-            // note(cyrusn): this could have been written like so:
-            //
-            //  return
-            //    this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword &&
-            //    this.PeekToken(1).Kind == SyntaxKind.VoidKeyword;
-            //
-            // However, we want to be lenient and allow the user to write 
-            // 'partial' in most modifier lists.  We will then provide them with
-            // a more specific message later in binding that they are doing 
-            // something wrong.
-            //
-            // Some might argue that the simple check would suffice.
-            // However, we'd like to maintain behavior with 
-            // previously shipped versions, and so we're keeping this code.
+            Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword);
+
+            // Check for:
+            //   partial event
+            if (this.PeekToken(1).Kind == SyntaxKind.EventKeyword)
+            {
+                return true;
+            }
 
-            // Here we check for:
+            // Check for constructor:
+            //   partial Identifier(
+            if (allowPartialCtor &&
+                this.PeekToken(1).Kind == SyntaxKind.IdentifierToken &&
+                this.PeekToken(2).Kind == SyntaxKind.OpenParenToken)
+            {
+                return true;
+            }
+
+            // Check for method/property:
             //   partial ReturnType MemberName
-            Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword);
             using var _ = this.GetDisposableResetPoint(resetOnDispose: true);
 
             this.EatToken(); // partial
@@ -5680,7 +5682,7 @@ private bool IsTrueIdentifier()
         {
             if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken)
             {
-                if (!IsCurrentTokenPartialKeywordOfPartialMethodOrType() &&
+                if (!IsCurrentTokenPartialKeywordOfPartialMemberOrType() &&
                     !IsCurrentTokenQueryKeywordInQuery() &&
                     !IsCurrentTokenWhereOfConstraintClause())
                 {
@@ -5727,7 +5729,7 @@ private SyntaxToken ParseIdentifierToken(ErrorCode code = ErrorCode.ERR_Identifi
                 // show the correct parameter help in this case.  So, when we see "partial" we check if it's being used
                 // as an identifier or as a contextual keyword.  If it's the latter then we bail out.  See
                 // Bug: vswhidbey/542125
-                if (IsCurrentTokenPartialKeywordOfPartialMethodOrType() || IsCurrentTokenQueryKeywordInQuery())
+                if (IsCurrentTokenPartialKeywordOfPartialMemberOrType() || IsCurrentTokenQueryKeywordInQuery())
                 {
                     var result = CreateMissingIdentifierToken();
                     result = this.AddError(result, ErrorCode.ERR_InvalidExprTerm, this.CurrentToken.Text);
@@ -5754,11 +5756,11 @@ private bool IsCurrentTokenQueryKeywordInQuery()
             return this.IsInQuery && this.IsCurrentTokenQueryContextualKeyword;
         }
 
-        private bool IsCurrentTokenPartialKeywordOfPartialMethodOrType()
+        private bool IsCurrentTokenPartialKeywordOfPartialMemberOrType()
         {
             if (this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword)
             {
-                if (this.IsPartialType() || this.IsPartialMember())
+                if (this.IsPartialType() || this.IsPartialMember(allowPartialCtor: false))
                 {
                     return true;
                 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceConstructorSymbol.cs

@@ -126,12 +126,17 @@ private static DeclarationModifiers MakeModifiers(
             var defaultAccess = (methodKind == MethodKind.StaticConstructor) ? DeclarationModifiers.None : DeclarationModifiers.Private;
 
             // Check that the set of modifiers is allowed
-            const DeclarationModifiers allowedModifiers =
+            DeclarationModifiers allowedModifiers =
                 DeclarationModifiers.AccessibilityMask |
                 DeclarationModifiers.Static |
                 DeclarationModifiers.Extern |
                 DeclarationModifiers.Unsafe;
 
+            if (methodKind == MethodKind.Constructor)
+            {
+                allowedModifiers |= DeclarationModifiers.Partial;
+            }
+
             bool isInterface = containingType.IsInterface;
             var mods = ModifierUtils.MakeAndCheckNonTypeMemberModifiers(isOrdinaryMethod: false, isForInterfaceMember: isInterface, syntax.Modifiers, defaultAccess, allowedModifiers, location, diagnostics, out modifierErrors);
 

src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs

@@ -10588,5 +10588,35 @@ void M()
                 //         [A(p)] void F() { }
                 Diagnostic(ErrorCode.WRN_UnreferencedLocalFunction, "F").WithArguments("F").WithLocation(13, 21));
         }
+
+        [Fact]
+        public void ReturningPartialType_InMethod()
+        {
+            var source = """
+                class @partial
+                {
+                    static void Main()
+                    {
+                        System.Console.Write(F().GetType().Name);
+
+                        partial F() => new();
+                    }
+                }
+                """;
+            CompileAndVerify(source, expectedOutput: "partial").VerifyDiagnostics();
+        }
+
+        [Fact]
+        public void ReturningPartialType_TopLevel()
+        {
+            var source = """
+                System.Console.Write(F().GetType().Name);
+
+                partial F() => new();
+
+                class @partial;
+                """;
+            CompileAndVerify(source, expectedOutput: "partial").VerifyDiagnostics();
+        }
     }
 }