Minor edits.

- Parse "call" as identifier in patterns and enum case names. Add tests.
- Disallow `@warn_unqualified_access` on `call` declarations.
- Update failing attribute tests.

Author: dan-zheng

include/swift/AST/Attr.def

@@ -309,7 +309,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(indirect, Indirect, DeclModifier |
   OnEnum | OnEnumElement,
   60)
 SIMPLE_DECL_ATTR(warn_unqualified_access, WarnUnqualifiedAccess,
-  OnFunc | OnAccessor | OnCall | /*OnVar |*/
+  OnFunc | OnAccessor | /*OnVar |*/
   LongAttribute,
   61)
 SIMPLE_DECL_ATTR(_show_in_interface, ShowInInterface,

lib/Parse/ParseDecl.cpp

@@ -5930,7 +5930,7 @@ Parser::parseDeclEnumCase(ParseDeclOptions Flags,
       return Status;
     }
 
-    if (Tok.is(tok::identifier)) {
+    if (Tok.is(tok::identifier) || Tok.is(tok::kw_call)) {
       Status |= parseIdentifierDeclName(*this, Name, NameLoc, "enum 'case'",
                                         tok::l_paren, tok::kw_case, tok::colon,
                                         tok::r_brace);

lib/Parse/ParsePattern.cpp

@@ -921,7 +921,8 @@ ParserResult<Pattern> Parser::parsePattern() {
     PatternCtx.setCreateSyntax(SyntaxKind::WildcardPattern);
     return makeParserResult(new (Context) AnyPattern(consumeToken(tok::kw__)));
 
-  case tok::identifier: {
+  case tok::identifier:
+  case tok::kw_call: {
     PatternCtx.setCreateSyntax(SyntaxKind::IdentifierPattern);
     Identifier name;
     SourceLoc loc = consumeIdentifier(&name);

lib/Parse/Parser.cpp

@@ -864,7 +864,7 @@ bool Parser::parseSpecificIdentifier(StringRef expected, SourceLoc &loc,
 /// its name in Result.  Otherwise, emit an error and return true.
 bool Parser::parseAnyIdentifier(Identifier &Result, SourceLoc &Loc,
                                 const Diagnostic &D) {
-  if (Tok.is(tok::identifier) || Tok.isAnyOperator()) {
+  if (Tok.is(tok::identifier) || Tok.isAnyOperator() || Tok.is(tok::kw_call)) {
     Result = Context.getIdentifier(Tok.getText());
     Loc = Tok.getLoc();
     consumeToken();

lib/Sema/TypeCheckAttr.cpp

@@ -690,6 +690,7 @@ void TypeChecker::checkDeclAttributesEarly(Decl *D) {
     StringRef OnlyKind;
     switch (PossibleDeclKinds) {
     case DeclAttribute::OnAccessor:    OnlyKind = "accessor"; break;
+    case DeclAttribute::OnCall:        OnlyKind = "call"; break;
     case DeclAttribute::OnClass:       OnlyKind = "class"; break;
     case DeclAttribute::OnConstructor: OnlyKind = "init"; break;
     case DeclAttribute::OnDestructor:  OnlyKind = "deinit"; break;

test/Parse/call_decl.swift

@@ -6,6 +6,21 @@ struct SimpleCallable {
   }
 }
 
+// Test source compatibility with existing usages of "call" as an identifier.
+
+struct CallFuncMember {
+  func call() {}
+}
+struct CallVarMember {
+  var call: Int
+}
+enum CallCase {
+  case call(call: Int)
+}
+protocol CallRequirement {
+  func call()
+}
+
 struct NoRedefinitionErrors {
   call(_ x: Int) -> Int {
     return x

test/Sema/immutability.swift

@@ -59,7 +59,7 @@ class FooClass {
     self = FooClass()  // expected-error {{cannot assign to value: 'self' is immutable}}
   }
 
-  mutating init(a : Bool) {}     // expected-error {{'mutating' may only be used on 'func' declarations}} {{3-12=}}
+  mutating init(a : Bool) {}     // expected-error {{'mutating' modifier cannot be applied to this declaration}} {{3-12=}}
 
   mutating            // expected-error {{'mutating' isn't valid on methods in classes or class-bound protocols}} {{3-12=}}
   func baz() {}

test/attr/attr_cdecl.swift

@@ -8,7 +8,7 @@ func emptyName(x: Int) -> Int { return x }
 @_cdecl("noBody")
 func noBody(x: Int) -> Int // expected-error{{expected '{' in body of function}}
 
-@_cdecl("property") // expected-error{{may only be used on 'func' declarations}}
+@_cdecl("property") // expected-error{{cannot be applied to this declaration}}
 var property: Int
 
 var computed: Int {
@@ -40,10 +40,10 @@ class Foo {
   @_cdecl("Foo_foo_2") // expected-error{{can only be applied to global functions}}
   static func foo(x: Int) -> Int { return x }
 
-  @_cdecl("Foo_init") // expected-error{{may only be used on 'func'}}
+  @_cdecl("Foo_init") // expected-error{{cannot be applied to this declaration}}
   init() {}
 
-  @_cdecl("Foo_deinit") // expected-error{{may only be used on 'func'}}
+  @_cdecl("Foo_deinit") // expected-error{{cannot be applied to this declaration}}
   deinit {}
 }