Extended property patterns: address PROTOTYPE comments

docs/contributing/Compiler Test Plan.md

@@ -92,7 +92,7 @@ This document provides guidance for thinking about language interactions and tes
 - Ref return, ref readonly return, ref ternary, ref readonly local, ref local re-assignment, ref foreach
 - `this = e;` in `struct` .ctor
 - Stackalloc (including initializers)
-- Patterns (constant, declaration, `var`, positional, property, discard, parenthesized, type, relational, `and`/`or`/`not`)
+- Patterns (constant, declaration, `var`, positional, property and extended property, discard, parenthesized, type, relational, `and`/`or`/`not`)
 - Switch expressions
 - With expressions (on record classes and on value types)
 - Nullability annotations (`?`, attributes) and analysis

docs/features/patterns.work.md

@@ -30,7 +30,7 @@
   - [ ] Test all of the ways that a name would not be valid to name a property in a property pattern
   - [ ] Need to design the data representation for edit-and-continue for temps in patterns
   - [ ] Need to precisely share temps per the edit-and-continue spec
-  - [ ] Need bullets here or github issues for PROTOTYPE(patterns2) comments.
+  - [ ] Need bullets here or github issues for prototype comments.
 
 - [ ] Need to ensure good code quality, e.g. avoid redundant null checks preceding types tests
 - [ ] Need to ensure a good tradeoff between decision tree size explosion and execution of redundant tests.

eng/targets/Settings.props

@@ -208,8 +208,7 @@
                       and hence suppress this warning until we get closer to release and a more
                       thorough documentation story
         -->
-        <!-- PROTOTYPE(extended-property-patterns) PublicAPIs -->
-        <NoWarn>$(NoWarn);1573;1591;1701;RS0016</NoWarn>
+        <NoWarn>$(NoWarn);1573;1591;1701</NoWarn>
       </PropertyGroup>
       <PropertyGroup>
         <DefineConstants Condition="'$(InitialDefineConstants)' != ''">$(DefineConstants);$(InitialDefineConstants)</DefineConstants>

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

@@ -200,6 +200,12 @@ internal BoundPattern BindConstantPatternWithFallbackToTypePattern(
             bool hasErrors,
             BindingDiagnosticBag diagnostics)
         {
+            if (hasSuppression(expression))
+            {
+                diagnostics.Add(ErrorCode.ERR_IllegalSuppression, expression.Location);
+                hasErrors = true;
+            }
+
             ExpressionSyntax innerExpression = SkipParensAndNullSuppressions(expression);
             if (innerExpression.Kind() == SyntaxKind.DefaultLiteralExpression)
             {
@@ -222,6 +228,23 @@ internal BoundPattern BindConstantPatternWithFallbackToTypePattern(
                 bool isExplicitNotNullTest = boundType.Type.SpecialType == SpecialType.System_Object;
                 return new BoundTypePattern(node, boundType, isExplicitNotNullTest, inputType, boundType.Type, hasErrors);
             }
+
+            static bool hasSuppression(ExpressionSyntax e)
+            {
+                while (true)
+                {
+                    switch (e)
+                    {
+                        case ParenthesizedExpressionSyntax p:
+                            e = p.Expression;
+                            break;
+                        case PostfixUnaryExpressionSyntax { RawKind: (int)SyntaxKind.SuppressNullableWarningExpression }:
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+            }
         }
 
         private ExpressionSyntax SkipParensAndNullSuppressions(ExpressionSyntax e)
@@ -777,10 +800,12 @@ deconstructMethod is null &&
             for (int i = 0; i < node.Subpatterns.Count; i++)
             {
                 var subPattern = node.Subpatterns[i];
+                // If the expression before the colon isn't just a name, we'll have reported a parsing error.
+                Debug.Assert(subPattern.NameColon is not null || subPattern.ExpressionColon is null || subPattern.ExpressionColon.HasErrors);
+
                 bool isError = hasErrors || outPlaceholders.IsDefaultOrEmpty || i >= outPlaceholders.Length;
                 TypeSymbol elementType = isError ? CreateErrorType() : outPlaceholders[i].Type;
                 ParameterSymbol? parameter = null;
-                // PROTOTYPE(extended-property-patterns) ExpressionColon
                 if (subPattern.NameColon != null && !isError)
                 {
                     // Check that the given name is the same as the corresponding parameter of the method.
@@ -819,7 +844,9 @@ private void BindITupleSubpatterns(
             var objectType = Compilation.GetSpecialType(SpecialType.System_Object);
             foreach (var subpatternSyntax in node.Subpatterns)
             {
-                // PROTOTYPE(extended-property-patterns) ExpressionColon
+                // If the expression before the colon isn't just a name, we'll have reported a parsing error.
+                Debug.Assert(subpatternSyntax.NameColon is not null || subpatternSyntax.ExpressionColon is null || subpatternSyntax.ExpressionColon.HasErrors);
+
                 if (subpatternSyntax.NameColon != null)
                 {
                     // error: name not permitted in ITuple deconstruction
@@ -873,10 +900,12 @@ private void BindValueTupleSubpatterns(
             for (int i = 0; i < node.Subpatterns.Count; i++)
             {
                 var subpatternSyntax = node.Subpatterns[i];
+                // If the expression before the colon isn't just a name, we'll have reported a parsing error.
+                Debug.Assert(subpatternSyntax.NameColon is not null || subpatternSyntax.ExpressionColon is null || subpatternSyntax.ExpressionColon.HasErrors);
+
                 bool isError = i >= elementTypesWithAnnotations.Length;
                 TypeSymbol elementType = isError ? CreateErrorType() : elementTypesWithAnnotations[i].Type;
                 FieldSymbol? foundField = null;
-                // PROTOTYPE(extended-property-patterns) ExpressionColon
                 if (subpatternSyntax.NameColon != null && !isError)
                 {
                     string name = subpatternSyntax.NameColon.Name.Identifier.ValueText;

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1932,15 +1932,13 @@ internal enum ErrorCode
 
         #region diagnostics introduced for C# 10.0
 
-        // PROTOTYPE(extended-property-patterns) Temp values
-        ERR_InvalidNameInSubpattern = 9000,
-
         ERR_InheritingFromRecordWithSealedToString = 8912,
         ERR_HiddenPositionalMember = 8913,
         ERR_GlobalUsingInNamespace = 8914,
         ERR_GlobalUsingOutOfOrder = 8915,
         ERR_AttributesRequireParenthesizedLambdaExpression = 8916,
         ERR_CannotInferDelegateType = 8917,
+        ERR_InvalidNameInSubpattern = 8918,
 
         #endregion
 

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -339,6 +339,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureGlobalUsing:
                 case MessageID.IDS_FeatureInferredDelegateType: // semantic check
                 case MessageID.IDS_FeatureLambdaAttributes: // semantic check
+                case MessageID.IDS_FeatureExtendedPropertyPatterns:
                     return LanguageVersion.Preview;
 
                 // C# 9.0 features.
@@ -499,10 +500,6 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureSwitchOnBool: // Checked in the binder.
                     return LanguageVersion.CSharp2;
 
-                // PROTOTYPE(extended-property-patterns) Move
-                case MessageID.IDS_FeatureExtendedPropertyPatterns:
-                    return LanguageVersion.Preview;
-
                 // Special C# 2 feature: only a warning in C# 1.
                 case MessageID.IDS_FeatureModuleAttrLoc:
                     return LanguageVersion.CSharp1;

src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs

@@ -1580,87 +1580,93 @@ public override void VisitPattern(BoundPattern pattern)
             base.VisitPattern(pattern);
             var whenFail = StateWhenFalse;
             SetState(StateWhenTrue);
-            AssignPatternVariables(pattern);
+            assignPatternVariablesAndMarkReadProperties(pattern);
             SetConditionalState(this.State, whenFail);
-        }
 
-        /// <summary>
-        /// Find the pattern variables of the pattern, and make them definitely assigned if <paramref name="definitely"/>.
-        /// That would be false under "not" and "or" patterns.
-        /// </summary>
-        private void AssignPatternVariables(BoundPattern pattern, bool definitely = true)
-        {
-            switch (pattern.Kind)
+            // Find the pattern variables of the pattern, and make them definitely assigned if <paramref name="definitely"/>.
+            // That would be false under "not" and "or" patterns.
+            void assignPatternVariablesAndMarkReadProperties(BoundPattern pattern, bool definitely = true)
             {
-                case BoundKind.DeclarationPattern:
-                    {
-                        var pat = (BoundDeclarationPattern)pattern;
-                        if (definitely)
-                            Assign(pat, value: null, isRef: false, read: false);
-                        break;
-                    }
-                case BoundKind.DiscardPattern:
-                    break;
-                case BoundKind.ConstantPattern:
-                    {
-                        var pat = (BoundConstantPattern)pattern;
-                        this.VisitRvalue(pat.Value);
+                switch (pattern.Kind)
+                {
+                    case BoundKind.DeclarationPattern:
+                        {
+                            var pat = (BoundDeclarationPattern)pattern;
+                            if (definitely)
+                                Assign(pat, value: null, isRef: false, read: false);
+                            break;
+                        }
+                    case BoundKind.DiscardPattern:
                         break;
-                    }
-                case BoundKind.RecursivePattern:
-                    {
-                        var pat = (BoundRecursivePattern)pattern;
-                        if (!pat.Deconstruction.IsDefaultOrEmpty)
+                    case BoundKind.ConstantPattern:
+                        {
+                            var pat = (BoundConstantPattern)pattern;
+                            this.VisitRvalue(pat.Value);
+                            break;
+                        }
+                    case BoundKind.RecursivePattern:
                         {
-                            foreach (var subpat in pat.Deconstruction)
+                            var pat = (BoundRecursivePattern)pattern;
+                            if (!pat.Deconstruction.IsDefaultOrEmpty)
                             {
-                                AssignPatternVariables(subpat.Pattern, definitely);
+                                foreach (var subpat in pat.Deconstruction)
+                                {
+                                    assignPatternVariablesAndMarkReadProperties(subpat.Pattern, definitely);
+                                }
                             }
+                            if (!pat.Properties.IsDefaultOrEmpty)
+                            {
+                                foreach (BoundSubpattern sub in pat.Properties)
+                                {
+                                    if (sub is BoundPropertySubpattern { Member: var member } )
+                                    {
+                                        while (member is not null && !member.HasErrors)
+                                        {
+                                            NoteRead(member.Symbol);
+                                            member = member.Receiver;
+                                        }
+                                    }
+                                    assignPatternVariablesAndMarkReadProperties(sub.Pattern, definitely);
+                                }
+                            }
+                            if (definitely)
+                                Assign(pat, null, false, false);
+                            break;
                         }
-                        if (!pat.Properties.IsDefaultOrEmpty)
+                    case BoundKind.ITuplePattern:
                         {
-                            foreach (BoundSubpattern sub in pat.Properties)
+                            var pat = (BoundITuplePattern)pattern;
+                            foreach (var subpat in pat.Subpatterns)
                             {
-                                AssignPatternVariables(sub.Pattern, definitely);
+                                assignPatternVariablesAndMarkReadProperties(subpat.Pattern, definitely);
                             }
+                            break;
                         }
-                        if (definitely)
-                            Assign(pat, null, false, false);
+                    case BoundKind.TypePattern:
                         break;
-                    }
-                case BoundKind.ITuplePattern:
-                    {
-                        var pat = (BoundITuplePattern)pattern;
-                        foreach (var subpat in pat.Subpatterns)
+                    case BoundKind.RelationalPattern:
                         {
-                            AssignPatternVariables(subpat.Pattern, definitely);
+                            var pat = (BoundRelationalPattern)pattern;
+                            this.VisitRvalue(pat.Value);
+                            break;
                         }
-                        break;
-                    }
-                case BoundKind.TypePattern:
-                    break;
-                case BoundKind.RelationalPattern:
-                    {
-                        var pat = (BoundRelationalPattern)pattern;
-                        this.VisitRvalue(pat.Value);
-                        break;
-                    }
-                case BoundKind.NegatedPattern:
-                    {
-                        var pat = (BoundNegatedPattern)pattern;
-                        AssignPatternVariables(pat.Negated, definitely: false);
-                        break;
-                    }
-                case BoundKind.BinaryPattern:
-                    {
-                        var pat = (BoundBinaryPattern)pattern;
-                        bool def = definitely && !pat.Disjunction;
-                        AssignPatternVariables(pat.Left, def);
-                        AssignPatternVariables(pat.Right, def);
-                        break;
-                    }
-                default:
-                    throw ExceptionUtilities.UnexpectedValue(pattern.Kind);
+                    case BoundKind.NegatedPattern:
+                        {
+                            var pat = (BoundNegatedPattern)pattern;
+                            assignPatternVariablesAndMarkReadProperties(pat.Negated, definitely: false);
+                            break;
+                        }
+                    case BoundKind.BinaryPattern:
+                        {
+                            var pat = (BoundBinaryPattern)pattern;
+                            bool def = definitely && !pat.Disjunction;
+                            assignPatternVariablesAndMarkReadProperties(pat.Left, def);
+                            assignPatternVariablesAndMarkReadProperties(pat.Right, def);
+                            break;
+                        }
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(pattern.Kind);
+                }
             }
         }