Parser: Generalize : lookahead to disambiguate all parameter specifiers as argument labels

Author: jckarter

include/swift/Parse/Parser.h

@@ -1150,7 +1150,6 @@ class Parser {
     // the following token is something that can introduce a type. Thankfully
     // none of these tokens overlap with the set of tokens that can follow an
     // identifier in a type production.
-    
     return Tok.is(tok::identifier)
       && peekToken().isAny(tok::at_sign,
                            tok::kw_inout,

lib/AST/ASTPrinter.cpp

@@ -1182,7 +1182,7 @@ void PrintAST::printAttributes(const Decl *D) {
     }
   }
 
-  // We will handle 'mutating' and 'nonmutating' separately.
+  // We will handle ownership specifiers separately.
   if (isa<FuncDecl>(D)) {
     Options.ExcludeAttrList.push_back(DAK_Mutating);
     Options.ExcludeAttrList.push_back(DAK_NonMutating);

lib/Parse/ParsePattern.cpp

@@ -171,14 +171,14 @@ bool Parser::startsParameterName(bool isClosure) {
         !Tok.is(tok::kw_repeat))
       return true;
 
-    // "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
+    // Parameter specifiers can be an argument label, but they're also
+    // 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 &) {
       if (Tok.is(tok::colon))
         return true; // isolated :
 
-      // isolated x :
       return Tok.canBeArgumentLabel() && nextTok.is(tok::colon);
     });
   }
@@ -262,6 +262,17 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
                      || Tok.isContextualKeyword("consuming")
                      || Tok.isContextualKeyword("isolated")
                      || Tok.isContextualKeyword("_const")))) {
+        // is this token the identifier of an argument label?
+        bool partOfArgumentLabel = lookahead<bool>(1, [&](CancellableBacktrackingScope &) {
+          if (Tok.is(tok::colon))
+            return true;  // isolated :
+
+          return Tok.canBeArgumentLabel() && peekToken().is(tok::colon);
+        });
+
+        if (partOfArgumentLabel)
+          break;
+
         if (Tok.isContextualKeyword("isolated")) {
           // did we already find an 'isolated' type modifier?
           if (param.IsolatedLoc.isValid()) {
@@ -271,18 +282,6 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
             continue;
           }
 
-          // is this 'isolated' token the identifier of an argument label?
-          bool partOfArgumentLabel = lookahead<bool>(1, [&](CancellableBacktrackingScope &) {
-            if (Tok.is(tok::colon))
-              return true;  // isolated :
-
-            // isolated x :
-            return Tok.canBeArgumentLabel() && peekToken().is(tok::colon);
-          });
-
-          if (partOfArgumentLabel)
-            break;
-
           // consume 'isolated' as type modifier
           param.IsolatedLoc = consumeToken();
           continue;

lib/Sema/TypeCheckProtocol.cpp

@@ -3573,7 +3573,7 @@ printRequirementStub(ValueDecl *Requirement, DeclContext *Adopter,
     if (AdopterIsClass || !isa<AbstractStorageDecl>(Requirement))
       Options.ExcludeAttrList.push_back(DAK_NonMutating);
 
-    // FIXME: Once we support move-only types, remove this if the
+    // FIXME: Once we support move-only types in generics, remove this if the
     //        conforming type is move-only. Until then, don't suggest printing
     //        __consuming on a protocol requirement.
     Options.ExcludeAttrList.push_back(DAK_Consuming);

om.swift

@@ -0,0 +1,27 @@
+// RUN: %target-typecheck-verify-swift
+
+struct borrowing {}
+struct consuming {}
+
+struct Foo {}
+
+func foo(x: borrowing Foo) {}
+func bar(x: consuming Foo) {}
+func baz(x: (borrowing Foo, consuming Foo) -> ()) {}
+
+//func bad(x: borrowing borrowing Foo) {} // expected-error{{at most one}}
+//func worse(x: borrowing consuming Foo) {} // expected-error{{at most one}}
+//func worst(x: (borrowing consuming Foo) -> ()) {} // expected-error{{at most one}}
+
+// `borrowing` and `consuming` are contextual keywords, so they should also
+// continue working as type and/or parameter names
+
+func zim(x: borrowing) {}
+func zang(x: consuming) {}
+func zung(x: borrowing consuming) {}
+func zip(x: consuming borrowing) {}
+func zap(x: (borrowing, consuming) -> ()) {}
+func zoop(x: (borrowing consuming, consuming borrowing) -> ()) {}
+
+//func worster(x: borrowing borrowing borrowing) {} // expected-error{{at most one}}
+//func worstest(x: (borrowing borrowing borrowing) -> ()) {} // expected-error{{at most one}}

test/Parse/ownership_modifiers.swift

@@ -1,4 +1,3 @@
-// TODO: implement new parser support for borrowing and consuming modifiers
 // RUN: %target-typecheck-verify-swift
 
 struct borrowing {}
@@ -26,3 +25,24 @@ func zoop(x: (borrowing consuming, consuming borrowing) -> ()) {}
 
 func worster(x: borrowing borrowing borrowing) {} // expected-error{{at most one}}
 func worstest(x: (borrowing borrowing borrowing) -> ()) {} // expected-error{{at most one}}
+
+// Parameter specifier names are regular identifiers in other positions,
+// including argument labels.
+
+func argumentLabel(borrowing consuming: Int) {}
+func argumentLabel(consuming borrowing: Int) {}
+func argumentLabel(__shared __owned: Int) {}
+func argumentLabel(__owned __shared: Int) {}
+
+// We should parse them as argument labels in function types, even though that
+// isn't currently supported.
+
+func argumentLabel(borrowingInClosure: (borrowing consuming: Int) -> ()) {} // expected-error{{function types cannot have argument labels}}
+func argumentLabel(consumingInClosure: (consuming borrowing: Int) -> ()) {} // expected-error{{function types cannot have argument labels}}
+func argumentLabel(sharedInClosure: (__shared __owned: Int) -> ()) {} // expected-error{{function types cannot have argument labels}}
+func argumentLabel(ownedInClosure: (__shared __owned: Int) -> ()) {} // expected-error{{function types cannot have argument labels}}
+
+func argumentLabel(anonBorrowingInClosure: (_ consuming: Int) -> ()) {}
+func argumentLabel(anonConsumingInClosure: (_ borrowing: Int) -> ()) {}
+func argumentLabel(anonSharedInClosure: (_ __owned: Int) -> ()) {}
+func argumentLabel(anonOwnedInClosure: (_ __owned: Int) -> ()) {}