Pull SE-0081 into Swift 3.0 Preview 1 (#2850)

* Implement parser support for SE-0081 - Move 'where' clause to end of declaration
This patch includes testsuite changes to show each of the decls supported.

Next step is to migrate the stdlib + testsuite + corelibs: I'd would *greatly* appreciate help with this.

After that is done, deprecation + migration of the old form can happen.

* My recent patch "broke" these tests, but allowing the syntax in them to trigger existing generics bugs.

Author: tkremenek

CHANGELOG.md

@@ -3,6 +3,32 @@ Note: This is in reverse chronological order, so newer entries are added to the
 Swift 3.0
 ---------
 
+* [SE-0081](https://github.com/apple/swift-evolution/blob/master/proposals/0081-move-where-expression.md)
+  "Move 'where' clause to end of declaration" is implemented, allowing you to 
+  write 'where' clauses after the signature for a declaration, but before its
+  body.  For example, before:
+
+    ```swift
+    func anyCommonElements<T : SequenceType, U : SequenceType 
+                           where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element>
+        (lhs: T, _ rhs: U) -> Bool
+    {
+        ...
+    }
+    ```
+
+  after:
+
+    ```swift
+    func anyCommonElements<T : SequenceType, U : SequenceType>(lhs: T, _ rhs: U) -> Bool
+        where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element>
+    {
+        ...
+    }
+    ```
+   
+  The old form is still accepted for compatibility, but will eventually be rejected.
+
 * [SE-0071](https://github.com/apple/swift-evolution/blob/master/proposals/0071-member-keywords.md):
   "Allow (most) keywords in member references" is implemented.  This allows the
   use of members after a dot without backticks, e.g. "foo.default".

include/swift/Parse/Parser.h

@@ -1240,9 +1240,13 @@ class Parser {
   ParserResult<GenericParamList> parseGenericParameters();
   ParserResult<GenericParamList> parseGenericParameters(SourceLoc LAngleLoc);
   ParserResult<GenericParamList> maybeParseGenericParams();
+  ParserStatus parseFreestandingGenericWhereClause(GenericParamList *&GPList);
+  
   ParserStatus parseGenericWhereClause(SourceLoc &WhereLoc,
                                SmallVectorImpl<RequirementRepr> &Requirements,
                                        bool &FirstTypeInComplete);
+  
+
 
   //===--------------------------------------------------------------------===//
   // Availability Specification Parsing

lib/Parse/ParseDecl.cpp

@@ -2930,10 +2930,10 @@ ParserResult<IfConfigDecl> Parser::parseDeclIfConfig(ParseDeclOptions Flags) {
 ///
 /// \verbatim
 ///   decl-typealias:
-///     'typealias' identifier generic-params? '=' type
+///     'typealias' identifier generic-params? '=' type requirement-clause?
 /// \endverbatim
-ParserResult<TypeDecl> Parser::parseDeclTypeAlias(Parser::ParseDeclOptions Flags,
-                                                  DeclAttributes &Attributes) {
+ParserResult<TypeDecl> Parser::
+parseDeclTypeAlias(Parser::ParseDeclOptions Flags, DeclAttributes &Attributes) {
   ParserPosition startPosition = getParserPosition();
   SourceLoc TypeAliasLoc = consumeToken(tok::kw_typealias);
   Identifier Id;
@@ -2991,6 +2991,13 @@ ParserResult<TypeDecl> Parser::parseDeclTypeAlias(Parser::ParseDeclOptions Flags
   if (UnderlyingTy.isNull())
     return Status;
 
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(genericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+  }
+  
   auto *TAD = new (Context) TypeAliasDecl(TypeAliasLoc, Id, IdLoc,
                                           UnderlyingTy.getPtrOrNull(),
                                           genericParams, CurDeclContext);
@@ -4408,7 +4415,8 @@ void Parser::consumeAbstractFunctionBody(AbstractFunctionDecl *AFD,
 /// \verbatim
 ///   decl-func:
 ///     attribute-list? ('static' | 'class')? 'mutating'? 'func' 
-///               any-identifier generic-params? func-signature stmt-brace?
+///               any-identifier generic-params? func-signature where-clause?
+///               stmt-brace?
 /// \endverbatim
 ///
 /// \note The caller of this method must ensure that the next token is 'func'.
@@ -4557,6 +4565,13 @@ Parser::parseDeclFunc(SourceLoc StaticLoc, StaticSpellingKind StaticSpelling,
     return SignatureStatus;
   }
 
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(GenericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+  }
+  
   // Protocol method arguments may not have default values.
   if (Flags.contains(PD_InProtocol) && DefaultArgs.HasDefaultArgument) {
     diagnose(FuncLoc, diag::protocol_method_argument_init);
@@ -4686,7 +4701,7 @@ bool Parser::parseAbstractFunctionBodyDelayed(AbstractFunctionDecl *AFD) {
 /// \verbatim
 ///   decl-enum:
 ///      'enum' attribute-list identifier generic-params? inheritance?
-///          '{' decl-enum-body '}'
+///          where-clause? '{' decl-enum-body '}'
 ///   decl-enum-body:
 ///      decl*
 /// \endverbatim
@@ -4729,6 +4744,14 @@ ParserResult<EnumDecl> Parser::parseDeclEnum(ParseDeclOptions Flags,
     Status |= parseInheritance(Inherited, /*classRequirementLoc=*/nullptr);
     UD->setInherited(Context.AllocateCopy(Inherited));
   }
+  
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(GenericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+    UD->setGenericParams(GenericParams);
+  }
 
   SourceLoc LBLoc, RBLoc;
   if (parseToken(tok::l_brace, LBLoc, diag::expected_lbrace_enum)) {
@@ -4966,7 +4989,7 @@ bool Parser::parseNominalDeclMembers(SourceLoc LBLoc, SourceLoc &RBLoc,
 /// \verbatim
 ///   decl-struct:
 ///      'struct' attribute-list identifier generic-params? inheritance?
-///          '{' decl-struct-body '}
+///          where-clause? '{' decl-struct-body '}
 ///   decl-struct-body:
 ///      decl*
 /// \endverbatim
@@ -5012,6 +5035,14 @@ ParserResult<StructDecl> Parser::parseDeclStruct(ParseDeclOptions Flags,
     Status |= parseInheritance(Inherited, /*classRequirementLoc=*/nullptr);
     SD->setInherited(Context.AllocateCopy(Inherited));
   }
+  
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(GenericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+    SD->setGenericParams(GenericParams);
+  }
 
   SourceLoc LBLoc, RBLoc;
   if (parseToken(tok::l_brace, LBLoc, diag::expected_lbrace_struct)) {
@@ -5047,7 +5078,7 @@ ParserResult<StructDecl> Parser::parseDeclStruct(ParseDeclOptions Flags,
 /// \verbatim
 ///   decl-class:
 ///      'class' attribute-list identifier generic-params? inheritance?
-///          '{' decl-class-body '}
+///          where-clause? '{' decl-class-body '}
 ///   decl-class-body:
 ///      decl*
 /// \endverbatim
@@ -5093,6 +5124,14 @@ ParserResult<ClassDecl> Parser::parseDeclClass(SourceLoc ClassLoc,
     CD->setInherited(Context.AllocateCopy(Inherited));
   }
 
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(GenericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+    CD->setGenericParams(GenericParams);
+  }
+
   SourceLoc LBLoc, RBLoc;
   if (parseToken(tok::l_brace, LBLoc, diag::expected_lbrace_class)) {
     LBLoc = PreviousLoc;
@@ -5376,6 +5415,13 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
     Attributes.add(new (Context) RethrowsAttr(throwsLoc));
   }
 
+  // Parse a 'where' clause if present, adding it to our GenericParamList.
+  if (Tok.is(tok::kw_where)) {
+    auto whereStatus = parseFreestandingGenericWhereClause(GenericParams);
+    if (whereStatus.shouldStopParsing())
+      return whereStatus;
+  }
+  
   auto *SelfDecl = ParamDecl::createUnboundSelf(ConstructorLoc, CurDeclContext);
 
   Scope S2(this, ScopeKind::ConstructorBody);

lib/Parse/ParseGeneric.cpp

@@ -260,3 +260,44 @@ ParserStatus Parser::parseGenericWhereClause(
 
   return Status;
 }
+
+
+/// Parse a free-standing where clause attached to a declaration, adding it to
+/// a generic parameter list that may (or may not) already exist.
+ParserStatus Parser::
+parseFreestandingGenericWhereClause(GenericParamList *&genericParams) {
+  assert(Tok.is(tok::kw_where) && "Shouldn't call this without a where");
+  
+  // Push the generic arguments back into a local scope so that references will
+  // find them.
+  Scope S(this, ScopeKind::Generics);
+  
+  if (genericParams)
+    for (auto pd : genericParams->getParams())
+      addToScope(pd);
+  
+  SmallVector<RequirementRepr, 4> Requirements;
+  if (genericParams)
+    Requirements.append(genericParams->getRequirements().begin(),
+                        genericParams->getRequirements().end());
+  
+  SourceLoc WhereLoc;
+  bool FirstTypeInComplete;
+  auto result = parseGenericWhereClause(WhereLoc, Requirements,
+                                        FirstTypeInComplete);
+  if (result.shouldStopParsing() || Requirements.empty())
+    return result;
+
+  if (!genericParams)
+    genericParams = GenericParamList::create(Context, SourceLoc(),
+                                             {}, WhereLoc, Requirements,
+                                             SourceLoc());
+  else
+    genericParams = GenericParamList::create(Context,
+                                             genericParams->getLAngleLoc(),
+                                             genericParams->getParams(),
+                                             WhereLoc, Requirements,
+                                             genericParams->getRAngleLoc());
+  return ParserStatus();
+}
+

test/Generics/associated_self_constraints.swift

@@ -63,7 +63,7 @@ protocol P {
 struct IP<T> : P {
     typealias A = T
 
-    init<O:P where O.A == IP.A>(x:O) {
+    init<O:P>(x:O) where O.A == IP.A {
        _onNext = { (item: A) in x.onNext(item) }
     }
 

test/Generics/function_defs.swift

@@ -189,9 +189,8 @@ func testOrdered<T : Ordered>(_ x: T, y: Int) {
 //===----------------------------------------------------------------------===//
 // Requires clauses
 //===----------------------------------------------------------------------===//
-func conformanceViaRequires<T 
-       where T : EqualComparable, T : MethodLessComparable
-     >(_ t1: T, t2: T) -> Bool {
+func conformanceViaRequires<T>(_ t1: T, t2: T) -> Bool
+    where T : EqualComparable, T : MethodLessComparable {
   let b1 = t1.isEqual(t2)
   if b1 || t1.isLess(t2) {
     return true
@@ -208,7 +207,8 @@ protocol AcceptsAnElement {
   func accept(_ e : Element)
 }
 
-func impliedSameType<T : GeneratesAnElement where T : AcceptsAnElement>(_ t: T) {
+func impliedSameType<T : GeneratesAnElement>(_ t: T)
+    where T : AcceptsAnElement {
   t.accept(t.makeIterator())
   let e = t.makeIterator(), e2 = t.makeIterator()
   if e.isEqual(e2) || e.isLess(e2) {
@@ -226,10 +226,9 @@ protocol GeneratesAssoc2 {
   func get() -> Assoc2
 }
 
-func simpleSameType
-       <T : GeneratesAssoc1, U : GeneratesAssoc2 where T.Assoc1 == U.Assoc2>
-       (_ t: T, u: U) -> Bool
-{
+func simpleSameType<T : GeneratesAssoc1, U : GeneratesAssoc2>
+  (_ t: T, u: U) -> Bool
+   where T.Assoc1 == U.Assoc2 {
   return t.get().isEqual(u.get()) || u.get().isLess(t.get())
 }
 
@@ -244,9 +243,9 @@ protocol GeneratesMetaAssoc2 {
 }
 
 func recursiveSameType
-       <T : GeneratesMetaAssoc1, U : GeneratesMetaAssoc2, V : GeneratesAssoc1
-        where T.MetaAssoc1 == V.Assoc1, V.Assoc1 == U.MetaAssoc2>
+       <T : GeneratesMetaAssoc1, U : GeneratesMetaAssoc2, V : GeneratesAssoc1>
        (_ t: T, u: U)
+  where T.MetaAssoc1 == V.Assoc1, V.Assoc1 == U.MetaAssoc2
 {
   t.get().accept(t.get().makeIterator())
   let e = t.get().makeIterator(), e2 = t.get().makeIterator()
@@ -265,12 +264,9 @@ protocol P2 {
   func getAssocP1() -> AssocP1
 }
 
-func beginsWith2<
-     E0: P1, E1: P1
-     where 
-       E0.Element == E1.Element, 
-       E0.Element : EqualComparable
-     >(_ e0: E0, _ e1: E1) -> Bool
+func beginsWith2<E0: P1, E1: P1>(_ e0: E0, _ e1: E1) -> Bool
+where E0.Element == E1.Element,
+      E0.Element : EqualComparable
 {
 }
 

test/Generics/generic_types.swift

@@ -63,9 +63,9 @@ struct formattedTestS<T : MyFormattedPrintable> {
   }
 }
 
-struct GenericReq<
-  T : IteratorProtocol, U : IteratorProtocol where T.Element == U.Element
-> {}
+struct GenericReq<T : IteratorProtocol, U : IteratorProtocol>
+  where T.Element == U.Element {
+}
 
 func getFirst<R : IteratorProtocol>(_ r: R) -> R.Element {
   var r = r
@@ -138,11 +138,8 @@ var d2 : Dictionary<String, Int>
 d1["hello"] = d2["world"]
 i = d2["blarg"]
 
-struct RangeOfPrintables<
-  R : Sequence
-  where
-  R.Iterator.Element : MyFormattedPrintable
-> {
+struct RangeOfPrintables<R : Sequence>
+  where R.Iterator.Element : MyFormattedPrintable {
   var r : R
 
   func format() -> String {
@@ -307,7 +304,7 @@ struct X4 : P, Q {
   typealias AssocQ = String
 }
 
-struct X5<T, U where T: P, T: Q, T.AssocP == T.AssocQ> { } // expected-note{{requirement specified as 'T.AssocP' == 'T.AssocQ' [with T = X4]}}
+struct X5<T, U> where T: P, T: Q, T.AssocP == T.AssocQ { } // expected-note{{requirement specified as 'T.AssocP' == 'T.AssocQ' [with T = X4]}}
 
 var y: X5<X4, Int> // expected-error{{'X5' requires the types 'AssocP' (aka 'Int') and 'AssocQ' (aka 'String') be equivalent}}
 
@@ -334,4 +331,4 @@ struct UnsolvableInheritance2<T : U.A, U : T.A> {}
 // expected-error@-1 {{inheritance from non-protocol, non-class type 'U.A'}}
 // expected-error@-2 {{inheritance from non-protocol, non-class type 'T.A'}}
 
-enum X7<T where X7.X : G> { case X } // expected-error{{'X' is not a member type of 'X7<T>'}}
+enum X7<T> where X7.X : G { case X } // expected-error{{'X' is not a member type of 'X7<T>'}}

test/IRGen/mixed_objc_native_protocol_constraints.swift

@@ -5,5 +5,5 @@
 
 protocol Fooable { func foo() }
 
-class A<B: Fooable where B: AnyObject> {
+class A<B: Fooable> where B: AnyObject{
 }

test/decl/nested.swift

@@ -78,7 +78,8 @@ class OuterNonGenericClass {
       init(t: T) { super.init(); self.t = t }
     }
 
-    class InnerGenericClass<U where U : Racoon, U.Stripes == T> : OuterNonGenericClass { // expected-error {{type 'InnerGenericClass' nested in generic function}}
+    class InnerGenericClass<U> : OuterNonGenericClass // expected-error {{type 'InnerGenericClass' nested in generic function}}
+        where U : Racoon, U.Stripes == T {
       let t: T
 
       init(t: T) { super.init(); self.t = t }
@@ -151,7 +152,8 @@ class OuterGenericClass<T> {
       init(t: T) { super.init(); self.t = t }
     }
 
-    class InnerGenericClass<U where U : Racoon, U.Stripes == T> : OuterGenericClass<U> { // expected-error {{type 'InnerGenericClass' nested in generic function}}
+    class InnerGenericClass<U> : OuterGenericClass<U> // expected-error {{type 'InnerGenericClass' nested in generic function}}
+      where U : Racoon, U.Stripes == T {
       let t: T
 
       init(t: T) { super.init(); self.t = t }

test/decl/typealias/typealias.swift

@@ -48,6 +48,9 @@ typealias BadC<T,T> = MyType<String, T>  // expected-error {{definition conflict
 
 typealias Tuple2<T1, T2> = (T1, T2)
 
+typealias Tuple3<T1> = (T1, T1) where T1 : Hashable
+
+
 let _ : Tuple2<Int, String> = (1, "foo")
 let _ : Tuple2 = (1, "foo")
 let _ : Tuple2<Int, String> = ("bar",  // expected-error {{cannot convert value of type 'String' to specified type 'Int'}}