Update for rebase

Author: jckarter

include/swift/Parse/Parser.h

@@ -1159,7 +1159,8 @@ class Parser {
                            tok::kw_Any,
                            tok::kw_Self,
                            tok::kw__,
-                           tok::kw_var);
+                           tok::kw_var,
+                           tok::kw_let);
   }
 
   ParserStatus parseTypeAttributeList(ParamDecl::Specifier &Specifier,

lib/Basic/LangOptions.cpp

@@ -32,9 +32,8 @@ using namespace swift;
 LangOptions::LangOptions() {
   // Note: Introduce default-on language options here.
 #ifndef NDEBUG
-#warning "reinstate parser round trip features once SwiftSyntax support is done"
-  //Features.insert(Feature::ParserRoundTrip);
-  //Features.insert(Feature::ParserValidation);
+  Features.insert(Feature::ParserRoundTrip);
+  Features.insert(Feature::ParserValidation);
 #endif
 }
 

lib/Parse/ParsePattern.cpp

@@ -262,17 +262,20 @@ 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;
-
+        // 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 &) {
+            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()) {

lib/SILGen/SILGenProlog.cpp

@@ -376,9 +376,19 @@ struct ArgumentInitHelper {
 
       // If our argument was owned, we use no implicit copy. Otherwise, we
       // use no copy.
-      auto kind = MarkMustCheckInst::CheckKind::NoConsumeOrAssign;
-      if (pd->isOwned())
+      MarkMustCheckInst::CheckKind kind;
+      switch (pd->getValueOwnership()) {
+      case ValueOwnership::Default:
+      case ValueOwnership::Shared:
+      case ValueOwnership::InOut:
+        kind = MarkMustCheckInst::CheckKind::NoConsumeOrAssign;
+        break;
+
+      case ValueOwnership::Owned:
         kind = MarkMustCheckInst::CheckKind::ConsumableAndAssignable;
+        break;
+      }
+
       value = SGF.B.createMarkMustCheckInst(loc, value, kind);
       SGF.emitManagedRValueWithCleanup(value);
       return completeUpdate(value);

lib/Sema/TypeCheckType.cpp

@@ -2353,8 +2353,7 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
   case TypeReprKind::Attributed:
     return resolveAttributedType(cast<AttributedTypeRepr>(repr), options);
   case TypeReprKind::Ownership:
-    return resolveSpecifierTypeRepr(cast<SpecifierTypeRepr>(repr), options);
-
+    return resolveOwnershipTypeRepr(cast<OwnershipTypeRepr>(repr), options);
   case TypeReprKind::Isolated:
     return resolveIsolatedTypeRepr(cast<IsolatedTypeRepr>(repr), options);
   case TypeReprKind::CompileTimeConst:

om.swift

@@ -40,9 +40,9 @@ func argumentLabel(__owned __shared: Int) {}
 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(ownedInClosure: (__owned __shared: 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(anonBorrowingInClosure: (_ borrowing: Int) -> ()) {}
+func argumentLabel(anonConsumingInClosure: (_ consuming: Int) -> ()) {}
+func argumentLabel(anonSharedInClosure: (_ __shared: Int) -> ()) {}
 func argumentLabel(anonOwnedInClosure: (_ __owned: Int) -> ()) {}

test/Parse/ownership_modifiers.swift

@@ -0,0 +1,41 @@
+// RUN: %target-typecheck-verify-swift
+
+// This is a variation of `ownership_modifiers.swift` with the expected error
+// lines removed, so that the file is parsed by the SwiftSyntax parser
+// and we validate that both parsers correctly handle this file.
+
+struct borrowing {}
+struct consuming {}
+
+struct Foo {}
+
+func foo(x: borrowing Foo) {}
+func bar(x: consuming Foo) {}
+func baz(x: (borrowing Foo, consuming Foo) -> ()) {}
+
+// `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) -> ()) {}
+
+// 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(anonBorrowingInClosure: (_ borrowing: Int) -> ()) {}
+func argumentLabel(anonConsumingInClosure: (_ consuming: Int) -> ()) {}
+func argumentLabel(anonSharedInClosure: (_ __shared: Int) -> ()) {}
+func argumentLabel(anonOwnedInClosure: (_ __owned: Int) -> ()) {}