[SE-0095] simplifyTypeExpr for composition expressions

Also adds:
- Any is caught before doing an unconstrained lookup, and the
protocol<> type is emitted
- composition expressions can be handled by
`PreCheckExpression::simplifyTypeExpr` to so you can do lookups like (P
& Q).self
- Fixits corrected & new tests added
- Typeref lowering cases should have been optional
- This fixes a failing test case.

Author: joewillsher

CHANGELOG.md

@@ -3,6 +3,19 @@ Note: This is in reverse chronological order, so newer entries are added to the
 Swift 3.0
 ---------
 
+* [SE-0095](https://github.com/apple/swift-evolution/blob/master/proposals/0095-any-as-existential.md):
+The `protocol<...>` composition construct has been removed. In its place, an infix type operator `&` has been introduced.
+
+```swift
+let a: Foo & Bar
+let b = value as? A & B & C
+func foo<T : Foo & Bar>(x: T) { … }
+func bar(x: Foo & Bar) { … }
+typealias G = GenericStruct<Foo & Bar>
+```
+
+The empty protocol composition, the `Any` type, was previously defined as being `protocol<>`. This has been removed from the standard library and `Any` is now a keyword with the same behaviour.
+
 * [SE-0091](https://github.com/apple/swift-evolution/blob/master/proposals/0091-improving-operators-in-protocols.md):
   Operators can now be defined within types or extensions thereof. For example:
 
@@ -93,6 +106,7 @@ Swift 3.0
   Similarly, the new `RecoverableError` and `CustomNSError` protocols
   allow additional control over the handling of the error.
 
+
 * [SE-0060](https://github.com/apple/swift-evolution/blob/master/proposals/0060-defaulted-parameter-order.md):
   Function parameters with default arguments must now be specified in
   declaration order. A call site must always supply the arguments it provides

include/swift/AST/ASTContext.h

@@ -443,8 +443,6 @@ class ASTContext {
   /// Retrieve the declaration of Swift.Void.
   TypeAliasDecl *getVoidDecl() const;
 
-  TypeAliasDecl *getAnyDecl() const;
-
   /// Retrieve the declaration of ObjectiveC.ObjCBool.
   StructDecl *getObjCBoolDecl();
 

include/swift/AST/DiagnosticsParse.def

@@ -656,7 +656,7 @@ ERROR(disallowed_protocol_composition,PointsToFirstBadToken,
       "protocol composition is neither allowed nor needed here", ())
 
 WARNING(deprecated_protocol_composition,PointsToFirstBadToken,
-        "'protocol<...>' composition syntax is deprecated; use infix '&' instead", ())
+        "'protocol<...>' composition syntax is deprecated; join the protocols using '&'", ())
 WARNING(deprecated_any_composition,PointsToFirstBadToken,
         "'protocol<>' syntax is deprecated; use 'Any' instead", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -517,7 +517,7 @@ ERROR(reserved_member_name,none,
 ERROR(invalid_redecl,none,"invalid redeclaration of %0", (DeclName))
 NOTE(invalid_redecl_prev,none,
      "%0 previously declared here", (DeclName))
-ERROR(invalid_redecl_any,none,"invalid redeclaration of 'Any'; cannot override type keyword", ())
+ERROR(invalid_redecl_any,none,"invalid redeclaration of 'Any'; cannot overload type keyword", ())
 
 ERROR(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (Identifier))

lib/AST/ASTContext.cpp

@@ -802,24 +802,6 @@ TypeAliasDecl *ASTContext::getVoidDecl() const {
   return Impl.VoidDecl;
 }
 
-TypeAliasDecl *ASTContext::getAnyDecl() const {
-  if (Impl.VoidDecl) {
-    return Impl.VoidDecl;
-  }
-
-  // Go find 'Void' in the Swift module.
-  SmallVector<ValueDecl *, 1> results;
-  lookupInSwiftModule("Any", results);
-  for (auto result : results) {
-    if (auto typeAlias = dyn_cast<TypeAliasDecl>(result)) {
-      Impl.VoidDecl = typeAlias;
-      return typeAlias;
-    }
-  }
-
-  return Impl.VoidDecl;
-}
-
 StructDecl *ASTContext::getObjCBoolDecl() {
   if (!Impl.ObjCBoolDecl) {
     SmallVector<ValueDecl *, 1> results;

lib/Parse/ParseDecl.cpp

@@ -2435,41 +2435,36 @@ ParserStatus Parser::parseInheritance(SmallVectorImpl<TypeLoc> &Inherited,
 
     auto usesDeprecatedCompositionSyntax = Tok.is(tok::kw_protocol) && startsWithLess(peekToken());
 
-    auto compositionResult = parseTypeIdentifierOrTypeComposition();
-    Status |= compositionResult;
+    auto ParsedTypeResult = parseTypeIdentifierOrTypeComposition();
+    Status |= ParsedTypeResult;
 
-    if (auto composition = dyn_cast_or_null<ProtocolCompositionTypeRepr>(compositionResult.getPtrOrNull())) {
+    // cannot inherit from composition
+    if (auto Composition = dyn_cast_or_null<ProtocolCompositionTypeRepr>(ParsedTypeResult.getPtrOrNull())) {
       // Record the protocols inside the composition.
-      Inherited.append(composition->getProtocols().begin(),
-                       composition->getProtocols().end());
+      Inherited.append(Composition->getProtocols().begin(),
+                       Composition->getProtocols().end());
       if (usesDeprecatedCompositionSyntax) {
         // Provide fixits to remove the composition, leaving the types intact.
-        auto compositionRange = composition->getCompositionRange();
-        diagnose(composition->getStartLoc(),
+        auto compositionRange = Composition->getCompositionRange();
+        diagnose(Composition->getStartLoc(),
                  diag::disallowed_protocol_composition)
-          .highlight({composition->getStartLoc(), compositionRange.End})
-          .fixItRemove({composition->getStartLoc(), compositionRange.Start})
+          .highlight({Composition->getStartLoc(), compositionRange.End})
+          .fixItRemove({Composition->getStartLoc(), compositionRange.Start})
           .fixItRemove(startsWithGreater(L->getTokenAt(compositionRange.End))
                      ? compositionRange.End
                      : SourceLoc());
       } else {
-        diagnose(composition->getStartLoc(),
+        diagnose(Composition->getStartLoc(),
                  diag::disallowed_protocol_composition)
-          .highlight(composition->getCompositionRange());
+          .highlight(Composition->getCompositionRange());
         // TODO: Decompose 'A & B & C' list to 'A, B, C'
       }
-      continue;
     } else {
-      // Parse the inherited type (which must be a protocol).
-      ParserResult<TypeRepr> Ty = compositionResult;
-      Status |= Ty;
-      // Record the type.
-      if (Ty.isNonNull())
-        Inherited.push_back(Ty.get());
+      // Record the type if its a single type.
+      if (ParsedTypeResult.isNonNull())
+        Inherited.push_back(ParsedTypeResult.get());
     }
 
-    
-
     // Check for a ',', which indicates that there are more protocols coming.
   } while (consumeIf(tok::comma, prevComma));
 

lib/Parse/ParseType.cpp

@@ -419,8 +419,7 @@ ParserResult<TypeRepr> Parser::parseTypeIdentifierOrTypeComposition() {
     // Check for empty protocol composition.
     if (startsWithGreater(Tok)) {
       SourceLoc RAngleLoc = consumeStartingGreater();
-      
-      auto AnyRange = SourceRange(LAngleLoc, RAngleLoc);
+      auto AnyRange = SourceRange(ProtocolLoc, RAngleLoc);
 
       // warn that 'protocol<>' is depreacted and offer to
       // repalace with the 'Any' keyword
@@ -470,10 +469,9 @@ ParserResult<TypeRepr> Parser::parseTypeIdentifierOrTypeComposition() {
 
     Diag.highlight({ProtocolLoc, RAngleLoc});
     for (auto Comma : Commas)          // remove commas and '<'
-      Diag.fixItReplace(Comma, " & ");
-    Diag // remove 'protocol<'
-      .fixItRemove(ProtocolLoc)
-      .fixItRemove(LAngleLoc)
+      Diag.fixItReplace(Comma, " &");
+    Diag
+      .fixItRemove({ProtocolLoc, LAngleLoc}) // remove 'protocol<'
       .fixItRemove(RAngleLoc); // remove '>'
 
     return makeParserResult(Status, composition);
@@ -501,7 +499,7 @@ ParserResult<TypeRepr> Parser::parseTypeIdentifierOrTypeComposition() {
         Protocols.push_back(Protocol.get());
     };
 
-    return makeParserResult(Status, ProtocolCompositionTypeRepr::create(Context, Protocols, FirstTypeLoc, {FirstTypeLoc, Tok.getLoc()}));
+    return makeParserResult(Status, ProtocolCompositionTypeRepr::create(Context, Protocols, FirstTypeLoc, {FirstTypeLoc, PreviousLoc}));
   }
 }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -435,6 +435,13 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
   DeclName Name = UDRE->getName();
   SourceLoc Loc = UDRE->getLoc();
 
+  // 'Any' is the empty protocol composition; resolve it before doing an
+  // unqualified lookup
+  if (Name.getBaseName() == Context.Id_Any) {
+    auto *TypeRepr = new (Context) ProtocolCompositionTypeRepr(ArrayRef<IdentTypeRepr *>(), Loc, UDRE->getSourceRange());
+    return new (Context) TypeExpr(TypeLoc(TypeRepr));
+  }
+
   // Perform standard value name lookup.
   NameLookupOptions LookupOptions = defaultUnqualifiedLookupOptions;
   if (isa<AbstractFunctionDecl>(DC))
@@ -1126,7 +1133,49 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
                                         ResultTypeRepr);
     return new (TC.Context) TypeExpr(TypeLoc(NewTypeRepr, Type()));
   }
-
+  
+  // Fold 'P & Q' into a composition type
+  if (auto *binaryExpr = dyn_cast<BinaryExpr>(E))
+    if (auto d = dyn_cast<OverloadedDeclRefExpr>(binaryExpr->getFn()))
+      for (auto decl : d->getDecls()) {
+        // for a composition
+        if (decl->getNameStr() == "&") {
+          // The protocols we are composing
+          SmallVector<IdentTypeRepr *, 4> Protocols;
+          
+          auto lhsExpr = binaryExpr->getArg()->getElement(0);
+          if (auto *lhs = dyn_cast_or_null<TypeExpr>(lhsExpr)) {
+            if (auto repr = dyn_cast<IdentTypeRepr>(lhs->getTypeRepr()))
+              Protocols.push_back(repr);
+          }
+          // if the lhs is another binary expression, we have a multi element composition:
+          // 'A & B & C' is parsed as ((A & B) & C), so we get the protocols from the lhs here
+          else if (isa<BinaryExpr>(lhsExpr)) {
+            if (auto *expr = simplifyTypeExpr(lhsExpr)) {
+              if (auto* repr = dyn_cast<ProtocolCompositionTypeRepr>(expr->getTypeRepr()))
+                for (auto proto : repr->getProtocols())
+                  Protocols.push_back(proto);
+            } else {
+              return nullptr;
+            }
+          } else {
+            return nullptr;
+          }
+          // add the rhs
+          auto rhs = dyn_cast_or_null<TypeExpr>(binaryExpr->getArg()->getElement(1));
+          if (!rhs) return nullptr;
+          
+          if (auto repr = dyn_cast<IdentTypeRepr>(rhs->getTypeRepr()))
+            Protocols.push_back(repr);
+          
+          auto CompositionRepr =
+            new (TC.Context) ProtocolCompositionTypeRepr(TC.Context.AllocateCopy(Protocols),
+                                                         binaryExpr->getLoc(),
+                                                         binaryExpr->getSourceRange());
+          return new (TC.Context) TypeExpr(TypeLoc(CompositionRepr, Type()));
+        }
+      }
+  
   return nullptr;
 }
 

lib/Sema/TypeCheckDecl.cpp

@@ -868,13 +868,12 @@ static void checkRedeclaration(TypeChecker &tc, ValueDecl *current) {
   if (!currentFile || currentDC->isLocalContext())
     return;
 
-  // Cannot define a global type called 'Any'
-  if (current->getFullName() == tc.Context.getIdentifier("Any")) {
-    // TODO: Diagnose this as an error; current workaround needs this capability though
-//    tc.diagnose(current, diag::invalid_redecl_any);
-//    return;
+  // Cannot define a type called 'Any'
+  if (current->getFullName() == tc.Context.Id_Any) {
+      tc.diagnose(current, diag::invalid_redecl_any);
+      return;
   }
-
+  
   ReferencedNameTracker *tracker = currentFile->getReferencedNameTracker();
   bool isCascading = true;
   if (current->hasAccessibility())

lib/Sema/TypeCheckType.cpp

@@ -824,7 +824,7 @@ resolveTopLevelIdentTypeComponent(TypeChecker &TC, DeclContext *DC,
 
     // if it is an 'Any' type, return the unbounded composition type
   } else if (comp->getIdentifier() == TC.Context.Id_Any) {
-    return ProtocolCompositionType::get(TC.Context, ArrayRef<Type>());
+    return TC.Context.TheAnyType;
   }
 
   // Resolve the first component, which is the only one that requires