Support module selectors in (ModName::+)

Author: beccadax

include/swift/Parse/Parser.h

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

@@ -3202,6 +3202,17 @@ Parser::parseExprList(tok leftTok, tok rightTok, SyntaxKind Kind) {
                         /*Implicit=*/false));
 }
 
+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);
+}
+
 /// parseExprList - Parse a list of expressions.
 ///
 ///   expr-paren:
@@ -3246,12 +3257,10 @@ ParserStatus Parser::parseExprList(tok leftTok, tok rightTok,
     // follows a proper subexpression.
     ParserStatus Status;
     Expr *SubExpr = nullptr;
-    if (Tok.isBinaryOperator() && peekToken().isAny(rightTok, tok::comma)) {
+    if (listElementIsBinaryOperator(*this, rightTok)) {
       SyntaxParsingContext operatorContext(SyntaxContext,
                                            SyntaxKind::IdentifierExpr);
       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 |
                                        DeclNameFlag::AllowModuleSelector);

lib/Parse/ParsePattern.cpp

@@ -175,7 +175,7 @@ bool Parser::startsParameterName(bool isClosure) {
     // "isolated" can be an argument label, but it's also a contextual keyword,
     // so look ahead one more token (two total) 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 :
 
@@ -281,7 +281,7 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
         }
 
         // is this 'isolated' token the identifier of an argument label?
-        bool partOfArgumentLabel = lookahead<bool>(1, [&](CancellableBacktrackingScope &) {
+        bool partOfArgumentLabel = lookahead(1, [&](CancellableBacktrackingScope &) {
           if (Tok.is(tok::colon))
             return true;  // isolated :
 

test/NameLookup/module_selector.swift

@@ -34,9 +34,7 @@ extension ModuleSelectorTestingKit::A: Swift::Equatable {
 
   @_dynamicReplacement(for: ModuleSelectorTestingKit::negate())
   mutating func myNegate() {
-    let fn: (Swift::Int, Swift::Int) -> Swift::Int =
-      (+)
-      // TODO: 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
     // expected-error@-1 {{cannot convert value of type 'Never' to specified type 'Int.Magnitude' (aka 'UInt')}}
@@ -93,9 +91,6 @@ extension B: main::Equatable {
     // expected-note@-3 {{did you mean module 'Swift'?}} {{25-29=Swift}}
     // expected-note@-4 {{did you mean module 'Swift'?}} {{39-43=Swift}}
       (main::+)
-      // TODO: it'd be nice to handle module selectors on operators.
-      // expected-error@-2 {{expected expression}}
-      // expected-error@-3 {{expected expression after operator}}
 
     let magnitude: Int.main::Magnitude = main::magnitude
     // expected-error@-1 {{type 'Magnitude' is not imported through module 'main'}}
@@ -160,9 +155,6 @@ extension C: ModuleSelectorTestingKit::Equatable {
     // expected-note@-3 {{did you mean module 'Swift'?}} {{45-69=Swift}}
     // expected-note@-4 {{did you mean module 'Swift'?}} {{79-103=Swift}}
       (ModuleSelectorTestingKit::+)
-      // TODO: it'd be nice to handle module selectors on operators.
-      // expected-error@-2 {{expected expression}}
-      // expected-error@-3 {{expected expression after operator}}
 
     let magnitude: Int.ModuleSelectorTestingKit::Magnitude = ModuleSelectorTestingKit::magnitude
     // expected-error@-1 {{type 'Magnitude' is not imported through module 'ModuleSelectorTestingKit'}}
@@ -225,10 +217,6 @@ extension D: Swift::Equatable {
 
     let fn: (Swift::Int, Swift::Int) -> Swift::Int =
       (Swift::+)
-      // TODO: 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
     // expected-error@-1 {{declaration 'magnitude' is not imported through module 'Swift'}}
     // expected-note@-2 {{did you mean module 'main'?}}

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)
+}