   public mutating func parsePostfixExpression(
     _ flavor: ExprFlavor,
     forDirective: Bool,
-    pattern: PatternContext,
-    periodHasKeyPathBehavior: Bool
+    pattern: PatternContext
   ) -> RawExprSyntax {
     let head = self.parsePrimaryExpression(pattern: pattern)
     guard !head.is(RawMissingExprSyntax.self) else {
       return head
     }
     return self.parsePostfixExpressionSuffix(
-      head, flavor, forDirective: forDirective,
-      periodHasKeyPathBehavior: periodHasKeyPathBehavior, pattern: pattern)
+      head, flavor, forDirective: forDirective, pattern: pattern)
   }
 
   @_spi(RawSyntax)


      // Check for a .foo suffix.
      if self.at(any: [.period, .prefixPeriod]) {
        // A key path is special, because it allows .[ and .<N>, unlike
        // anywhere else. The period itself should be left in the token stream.
        // (.? and .! end up being operators, and so aren't handled here.)
        if periodHasKeyPathBehavior {
          break
        }

        leadingExpr = self.parseDottedExpressionSuffix(leadingExpr)
        continue
      }

    default:
      // If the next token is not an operator, just parse this as expr-postfix.
      return self.parsePostfixExpression(
        flavor, forDirective: forDirective, pattern: pattern)
    }
  }

