Parse module selectors on operator references

Author: beccadax

include/swift/Parse/Parser.h

@@ -487,9 +487,8 @@ class Parser {
   /// \returns the value returned by \c f
   /// \note When calling, you may need to specify the \c Val type
   ///       explicitly as a type parameter.
-  template <typename Val>
-  Val lookahead(unsigned char K,
-                llvm::function_ref<Val(CancellableBacktrackingScope &)> f) {
+  template <typename Fn>
+  decltype(auto) lookahead(unsigned char K, Fn f) {
     CancellableBacktrackingScope backtrackScope(*this);
 
     for (unsigned char i = 0; i < K; ++i)

lib/Parse/ParseExpr.cpp

@@ -3247,19 +3247,26 @@ Parser::parseArgumentList(tok leftTok, tok rightTok, bool isExprBasic,
   return makeParserResult(status, argList);
 }
 
+/// See if we have an operator decl ref '(<op>)'. The operator token in
+/// this case lexes as a binary operator because it neither leads nor
+/// follows a proper subexpression.
+bool listElementIsBinaryOperator(Parser &P, tok rightTok) {
+  // Look past a module selector, if present.
+  if (P.Tok.is(tok::identifier) && P.peekToken().is(tok::colon_colon)) {
+    return P.lookahead(2, [&](auto &scope) {
+      return listElementIsBinaryOperator(P, rightTok);
+    });
+  }
+
+  return P.Tok.isBinaryOperator() && P.peekToken().isAny(rightTok, tok::comma);
+}
+
 ParserStatus Parser::parseExprListElement(tok rightTok, bool isArgumentList, SourceLoc leftLoc, SmallVectorImpl<ExprListElt> &elts) {
   Identifier FieldName;
   SourceLoc FieldNameLoc;
   parseOptionalArgumentLabel(FieldName, FieldNameLoc);
 
-  // See if we have an operator decl ref '(<op>)'. The operator token in
-  // this case lexes as a binary operator because it neither leads nor
-  // follows a proper subexpression.
-  auto isUnappliedOperator = [&]() {
-    return Tok.isBinaryOperator() && peekToken().isAny(rightTok, tok::comma);
-  };
-
-  if (isUnappliedOperator()) {
+  if (listElementIsBinaryOperator(*this, rightTok)) {
     // Check to see if we have the start of a regex literal `/.../`. We need
     // to do this for an unapplied operator reference, as e.g `(/, /)` might
     // be a regex literal.
@@ -3268,10 +3275,8 @@ ParserStatus Parser::parseExprListElement(tok rightTok, bool isArgumentList, Sou
 
   ParserStatus Status;
   Expr *SubExpr = nullptr;
-  if (isUnappliedOperator()) {
+  if (listElementIsBinaryOperator(*this, rightTok)) {
     DeclNameLoc Loc;
-    // FIXME: We would like to allow module selectors on binary operators, but
-    // the condition above won't let us reach this code.
     auto OperName =
         parseDeclNameRef(Loc, diag::expected_operator_ref,
                          DeclNameFlag::AllowOperators |

lib/Parse/ParsePattern.cpp

@@ -122,7 +122,7 @@ bool Parser::startsParameterName(bool isClosure) {
     // contextual keywords, so look ahead one more token (two total) and see
     // if we have a ':' that would
     // indicate that this is an argument label.
-    return lookahead<bool>(2, [&](CancellableBacktrackingScope &) {
+    return lookahead(2, [&](CancellableBacktrackingScope &) {
       if (Tok.is(tok::colon))
         return true; // isolated :
 
@@ -235,7 +235,7 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
         // is this token the identifier of an argument label? `inout` is a
         // reserved keyword but the other modifiers are not.
         if (!Tok.is(tok::kw_inout)) {
-          bool partOfArgumentLabel = lookahead<bool>(1, [&](CancellableBacktrackingScope &) {
+          bool partOfArgumentLabel = lookahead(1, [&](CancellableBacktrackingScope &) {
             if (Tok.is(tok::colon))
               return true;  // isolated :
 

test/NameLookup/module_selector.swift

@@ -24,9 +24,7 @@ extension A: @retroactive Swift::Equatable {
 
   @_dynamicReplacement(for: ModuleSelectorTestingKit::negate())
   mutating func myNegate() {
-    let fn: (Swift::Int, Swift::Int) -> Swift::Int =
-      (+)
-      // FIXME: it'd be nice to handle module selectors on operators.
+    let fn: (Swift::Int, Swift::Int) -> Swift::Int = (Swift::+)
 
     let magnitude: Int.Swift::Magnitude = main::magnitude
 
@@ -69,10 +67,6 @@ extension B: @retroactive main::Equatable {
   mutating func myNegate() {
     let fn: (main::Int, main::Int) -> main::Int =
       (main::+)
-      // FIXME: it'd be nice to handle module selectors on operators.
-      // expected-error@-2 {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}}
-      // expected-error@-3 {{expected expression}}
-      // expected-error@-4 {{expected expression after operator}}
 
     let magnitude: Int.main::Magnitude = main::magnitude
 
@@ -117,10 +111,6 @@ extension C: @retroactive ModuleSelectorTestingKit::Equatable {
   mutating func myNegate() {
     let fn: (ModuleSelectorTestingKit::Int, ModuleSelectorTestingKit::Int) -> ModuleSelectorTestingKit::Int =
       (ModuleSelectorTestingKit::+)
-      // FIXME: it'd be nice to handle module selectors on operators.
-      // expected-error@-2 {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}}
-      // expected-error@-3 {{expected expression}}
-      // expected-error@-4 {{expected expression after operator}}
 
     let magnitude: Int.ModuleSelectorTestingKit::Magnitude = ModuleSelectorTestingKit::magnitude
 
@@ -165,10 +155,6 @@ extension D: @retroactive Swift::Equatable {
   mutating func myNegate() {
     let fn: (Swift::Int, Swift::Int) -> Swift::Int =
       (Swift::+)
-      // FIXME: it'd be nice to handle module selectors on operators.
-      // expected-error@-2 {{cannot convert value of type '()' to specified type '(Int, Int) -> Int'}}
-      // expected-error@-3 {{expected expression}}
-      // expected-error@-4 {{expected expression after operator}}
 
     let magnitude: Int.Swift::Magnitude = Swift::magnitude
 

test/expr/postfix/dot/numeric_literals.swift

@@ -0,0 +1,9 @@
+// RUN: %target-typecheck-verify-swift
+
+func fn() {
+  _ = 1.description
+  _ = 1.5.description
+
+  print(1.description)
+  print(1.5.description)
+}