Implement extended property patterns

eng/targets/Settings.props

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

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

@@ -780,6 +780,7 @@ deconstructMethod is null &&
  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.
@@ -818,6 +819,7 @@ private void BindITupleSubpatterns(
  var objectType = Compilation.GetSpecialType(SpecialType.System_Object);
  foreach (var subpatternSyntax in node.Subpatterns)
  {
+ // PROTOTYPE(extended-property-patterns) ExpressionColon
  if (subpatternSyntax.NameColon != null)
  {
  // error: name not permitted in ITuple deconstruction
@@ -874,6 +876,7 @@ private void BindValueTupleSubpatterns(
  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;
@@ -1163,34 +1166,52 @@ private ImmutableArray<BoundSubpattern> BindPropertyPatternClause(
  var builder = ArrayBuilder<BoundSubpattern>.GetInstance(node.Subpatterns.Count);
  foreach (SubpatternSyntax p in node.Subpatterns)
  {
- IdentifierNameSyntax? name = p.NameColon?.Name;
+ ExpressionSyntax? expr = p.ExpressionColon?.Expression;
  PatternSyntax pattern = p.Pattern;
- Symbol? member = null;
+ ImmutableArray<Symbol> members;
  TypeSymbol memberType;
- if (name == null)
+ if (expr == null)
  {
  if (!hasErrors)
  diagnostics.Add(ErrorCode.ERR_PropertyPatternNameMissing, pattern.Location, pattern);
 
  memberType = CreateErrorType();
+ members = ImmutableArray<Symbol>.Empty;
  hasErrors = true;
  }
  else
  {
- member = LookupMemberForPropertyPattern(inputType, name, diagnostics, ref hasErrors, out memberType);
+ var memberBuilder = ArrayBuilder<Symbol>.GetInstance();
+ LookupMembersForPropertyPattern(inputType, expr, memberBuilder, diagnostics, ref hasErrors, out memberType);
+ members = memberBuilder.ToImmutableAndFree();
  }
 
  BoundPattern boundPattern = BindPattern(pattern, memberType, GetValEscape(memberType, inputValEscape), permitDesignations, hasErrors, diagnostics);
- builder.Add(new BoundSubpattern(p, member, boundPattern));
+ builder.Add(new BoundSubpattern(p, members, boundPattern));
  }
 
  return builder.ToImmutableAndFree();
  }
 
- private Symbol? LookupMemberForPropertyPattern(
- TypeSymbol inputType, IdentifierNameSyntax name, BindingDiagnosticBag diagnostics, ref bool hasErrors, out TypeSymbol memberType)
+ private void LookupMembersForPropertyPattern(
+ TypeSymbol inputType, ExpressionSyntax expr, ArrayBuilder<Symbol> builder, BindingDiagnosticBag diagnostics, ref bool hasErrors, out TypeSymbol memberType)
  {
- Symbol? symbol = BindPropertyPatternMember(inputType, name, ref hasErrors, diagnostics);
+ Symbol? symbol;
+ switch (expr)
+ {
+ case IdentifierNameSyntax name:
+ symbol = BindPropertyPatternMember(inputType, name, ref hasErrors, diagnostics);
+ break;
+ case MemberAccessExpressionSyntax { Name: IdentifierNameSyntax name } memberAccess when memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression):
+ LookupMembersForPropertyPattern(inputType, memberAccess.Expression, builder, diagnostics, ref hasErrors, out memberType);
+ symbol = BindPropertyPatternMember(memberType.StrippedType(), name, ref hasErrors, diagnostics);
+ break;
+ default:
+ Error(diagnostics, ErrorCode.ERR_InvalidNameInSubpattern, expr);
+ symbol = null;
+ hasErrors = true;
+ break;
+ }
 
  memberType = symbol switch
  {
@@ -1199,7 +1220,7 @@ private ImmutableArray<BoundSubpattern> BindPropertyPatternClause(
  _ => CreateErrorType()
  };
 
- return symbol;
+ builder.AddIfNotNull(symbol);
  }
 
  private Symbol? BindPropertyPatternMember(

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

@@ -527,29 +527,46 @@ private Tests MakeTestsAndBindingsForRecursivePattern(
  if (!recursive.Properties.IsDefault)
  {
  // we have a "property" form
- for (int i = 0; i < recursive.Properties.Length; i++)
+ foreach (var subpattern in recursive.Properties)
  {
- var subPattern = recursive.Properties[i];
- Symbol? symbol = subPattern.Symbol;
- BoundPattern pattern = subPattern.Pattern;
- BoundDagEvaluation evaluation;
- switch (symbol)
+ BoundPattern pattern = subpattern.Pattern;
+ BoundDagTemp currentInput = input;
+ if (subpattern.Symbols.IsEmpty)
  {
- case PropertySymbol property:
- evaluation = new BoundDagPropertyEvaluation(pattern.Syntax, property, OriginalInput(input, property));
- break;
- case FieldSymbol field:
- evaluation = new BoundDagFieldEvaluation(pattern.Syntax, field, OriginalInput(input, field));
+ addErrorTest();
+ goto done;
+ }
+
+ for (int index = 0, count = subpattern.Symbols.Length; ;)
+ {
+ Symbol symbol = subpattern.Symbols[index];
+ BoundDagEvaluation evaluation;
+ switch (symbol)
+ {
+ case PropertySymbol property:
+ evaluation = new BoundDagPropertyEvaluation(pattern.Syntax, property, OriginalInput(currentInput, property));
+ break;
+ case FieldSymbol field:
+ evaluation = new BoundDagFieldEvaluation(pattern.Syntax, field, OriginalInput(currentInput, field));
+ break;
+ default:
+ addErrorTest();
+ goto done;
+ }
+
+ tests.Add(new Tests.One(evaluation));
+ TypeSymbol type = symbol.GetTypeOrReturnType().Type;
+ currentInput = new BoundDagTemp(pattern.Syntax, type, evaluation);
+
+ if (++index == count)
  break;
- default:
- RoslynDebug.Assert(recursive.HasAnyErrors);
- tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true)));
- continue;
+
+ // If this is not the last member, add null test, unwrap nullables, and continue.
+ currentInput = MakeConvertToType(currentInput, pattern.Syntax, type.StrippedType(), isExplicitTest: false, tests);
  }
 
- tests.Add(new Tests.One(evaluation));
- var element = new BoundDagTemp(pattern.Syntax, symbol.GetTypeOrReturnType().Type, evaluation);
- tests.Add(MakeTestsAndBindings(element, pattern, bindings));
+done:
+ tests.Add(MakeTestsAndBindings(currentInput, pattern, bindings));
  }
  }
 
@@ -560,6 +577,12 @@ private Tests MakeTestsAndBindingsForRecursivePattern(
  }
 
  return Tests.AndSequence.Create(tests);
+
+ void addErrorTest()
+ {
+ Debug.Assert(recursive.HasAnyErrors);
+ tests.Add(new Tests.One(new BoundDagTypeTest(recursive.Syntax, ErrorType(), input, hasErrors: true)));
+ }
  }
 
  private Tests MakeTestsAndBindingsForNegatedPattern(BoundDagTemp input, BoundNegatedPattern neg, ArrayBuilder<BoundPatternBinding> bindings)

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -2092,7 +2092,7 @@
  <!-- A subpattern, either in a positional or property part of a recursive pattern. -->
  <Node Name="BoundSubpattern" Base="BoundNode">
  <!-- The tuple element or parameter in a positional pattern, or the property or field in a property pattern. -->
- <Field Name="Symbol" Type="Symbol?"/>
+ <Field Name="Symbols" Type="ImmutableArray&lt;Symbol&gt;"/>
  <Field Name="Pattern" Type="BoundPattern" Null="disallow"/>
  </Node>
 

src/Compilers/CSharp/Portable/BoundTree/BoundSubpattern.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System.Collections.Immutable;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+ // PROTOTYPE(extended-property-patterns) Split BoundPropertySubpattern and remove this (requires IOperation changes)
+ partial class BoundSubpattern
+ {
+ internal BoundSubpattern(SyntaxNode syntax, Symbol? symbol, BoundPattern pattern, bool hasErrors = false)
+ : this(syntax, symbol is null ? ImmutableArray<Symbol>.Empty : ImmutableArray.Create(symbol), pattern, hasErrors)
+ {
+ }
+
+ internal Symbol? Symbol
+ {
+ get
+ {
+ if (this.Symbols.IsEmpty)
+ return null;
+ if (this.Symbols.Length == 1)
+ return this.Symbols[0];
+ return null;
+ }
+ }
+ }
+}

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6609,4 +6609,10 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
  <data name="ERR_HiddenPositionalMember" xml:space="preserve">
  <value>The positional member '{0}' found corresponding to this parameter is hidden.</value>
  </data>
+ <data name="ERR_InvalidNameInSubpattern" xml:space="preserve">
+ <value>Identifier or a simple member access expected.</value>
+ </data>
+ <data name="IDS_FeatureExtendedPropertyPatterns" xml:space="preserve">
+ <value>extended property patterns</value>
+ </data>
 </root>

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

@@ -1934,6 +1934,9 @@ 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,
 

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

@@ -103,6 +103,9 @@ internal enum MessageID
 
  IDS_FeatureDiscards = MessageBase + 12688,
 
+ // PROTOTYPE(extended-property-patterns) Move
+ IDS_FeatureExtendedPropertyPatterns = MessageBase + 12800,
+
  IDS_FeatureDefaultTypeParameterConstraint = MessageBase + 12689,
  IDS_FeatureNullPropagatingOperator = MessageBase + 12690,
  IDS_FeatureExpressionBodiedMethod = MessageBase + 12691,
@@ -485,6 +488,10 @@ 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/NullableWalker_Patterns.cs

@@ -165,13 +165,17 @@ private void LearnFromAnyNullPatterns(
  // for property part
  if (!rp.Properties.IsDefault)
  {
- for (int i = 0, n = rp.Properties.Length; i < n; i++)
+ foreach (BoundSubpattern subpattern in rp.Properties)
  {
- BoundSubpattern item = rp.Properties[i];
- Symbol symbol = item.Symbol;
- if (symbol?.ContainingType.Equals(inputType, TypeCompareKind.AllIgnoreOptions) == true)
+ if (subpattern.Symbols.IsEmpty)
+ continue;
+
+ // Obtain the last symbol's slot which is actually the one being matched.
+ Symbol last = subpattern.Symbols.Last();
+ // PROTOTYPE(extended-property-patterns) For a chain of members, the input type is no longer `inputType`
+ if (last.ContainingType.Equals(inputType, TypeCompareKind.AllIgnoreOptions))
  {
- LearnFromAnyNullPatterns(GetOrCreateSlot(symbol, inputSlot), symbol.GetTypeOrReturnType().Type, item.Pattern);
+ LearnFromAnyNullPatterns(GetOrCreateSlot(last, inputSlot), last.GetTypeOrReturnType().Type, subpattern.Pattern);
  }
  }
  }