[SE-0095] Initial parsing implementation for '&' composition syntax

This commit defines the ‘Any’ keyword, implements parsing for composing
types with an infix ‘&’, and provides a fixit to convert ‘protocol<>’

- Updated tests & stdlib for new composition syntax
- Provide errors when compositions used in inheritance.
Any is treated as a contextual keyword. The name ‘Any’
is used emit the empty composition type. We have to
stop user declaring top level types spelled ‘Any’ too.

Author: joewillsher

include/swift/AST/ASTContext.h

@@ -443,7 +443,6 @@ class ASTContext {
   /// Retrieve the declaration of Swift.Void.
   TypeAliasDecl *getVoidDecl() const;
 
-  /// Retrieve the declaration of Swift.Any.
   TypeAliasDecl *getAnyDecl() const;
 
   /// Retrieve the declaration of ObjectiveC.ObjCBool.
@@ -568,7 +567,8 @@ class ASTContext {
   // Builtin type and simple types that are used frequently.
   const CanType TheErrorType;             /// This is the ErrorType singleton.
   const CanType TheUnresolvedType;        /// This is the UnresolvedType singleton.
-  const CanType TheEmptyTupleType;        /// This is "()", aka Void
+  const CanType TheEmptyTupleType;        /// This is '()', aka Void
+  const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
   const CanType TheNativeObjectType;      /// Builtin.NativeObject
   const CanType TheBridgeObjectType;      /// Builtin.BridgeObject
   const CanType TheUnknownObjectType;     /// Builtin.UnknownObject

include/swift/AST/DiagnosticsParse.def

@@ -655,6 +655,11 @@ ERROR(expected_rangle_protocol,PointsToFirstBadToken,
 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", ())
+WARNING(deprecated_any_composition,PointsToFirstBadToken,
+        "'protocol<>' syntax is deprecated; use 'Any' instead", ())
+
 //------------------------------------------------------------------------------
 // Pattern parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -517,6 +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(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (Identifier))
@@ -1387,7 +1388,7 @@ ERROR(circular_protocol_def,none,
 NOTE(protocol_here,none,
      "protocol %0 declared here", (Identifier))
 ERROR(protocol_composition_not_protocol,none, 
-      "non-protocol type %0 cannot be used within 'protocol<...>'", (Type))
+      "non-protocol type %0 cannot be used within a protocol composition", (Type))
 ERROR(objc_protocol_inherits_non_objc_protocol,none,
       "@objc protocol %0 cannot refine non-@objc protocol %1", (Type, Type))
 
@@ -2683,7 +2684,7 @@ ERROR(objc_convention_invalid,none,
 ERROR(function_type_no_parens,none,
       "single argument function types require parentheses", ())
 NOTE(not_objc_empty_protocol_composition,none,
-     "'protocol<>' is not considered '@objc'; use 'AnyObject' instead", ())
+     "'Any' is not considered '@objc'; use 'AnyObject' instead", ())
 NOTE(not_objc_protocol,none,
      "protocol %0 is not '@objc'", (Type))
 NOTE(not_objc_empty_tuple,none,

include/swift/AST/KnownIdentifiers.def

@@ -60,6 +60,7 @@ IDENTIFIER(RawValue)
 IDENTIFIER(Selector)
 IDENTIFIER(self)
 IDENTIFIER(Self)
+IDENTIFIER(Any)
 IDENTIFIER(setObject)
 IDENTIFIER(simd)
 IDENTIFIER(some)

include/swift/AST/TypeRepr.h

@@ -613,38 +613,38 @@ class NamedTypeRepr : public TypeRepr {
 
 /// \brief A protocol composite type.
 /// \code
-///   protocol<Foo, Bar>
+///   Foo & Bar
 /// \endcode
 class ProtocolCompositionTypeRepr : public TypeRepr {
   ArrayRef<IdentTypeRepr *> Protocols;
-  SourceLoc ProtocolLoc;
-  SourceRange AngleBrackets;
+  SourceLoc FirstTypeLoc;
+  SourceRange CompositionRange;
 
 public:
   ProtocolCompositionTypeRepr(ArrayRef<IdentTypeRepr *> Protocols,
-                              SourceLoc ProtocolLoc,
-                              SourceRange AngleBrackets)
+                              SourceLoc FirstTypeLoc,
+                              SourceRange CompositionRange)
     : TypeRepr(TypeReprKind::ProtocolComposition), Protocols(Protocols),
-      ProtocolLoc(ProtocolLoc), AngleBrackets(AngleBrackets) {
+    FirstTypeLoc(FirstTypeLoc), CompositionRange(CompositionRange) {
   }
 
   ArrayRef<IdentTypeRepr *> getProtocols() const { return Protocols; }
-  SourceLoc getProtocolLoc() const { return ProtocolLoc; }
-  SourceRange getAngleBrackets() const { return AngleBrackets; }
+  SourceLoc getStartLoc() const { return FirstTypeLoc; }
+  SourceRange getCompositionRange() const { return CompositionRange; }
 
   static ProtocolCompositionTypeRepr *create(ASTContext &C,
                                              ArrayRef<IdentTypeRepr*> Protocols,
-                                             SourceLoc ProtocolLoc,
-                                             SourceRange AngleBrackets);
+                                             SourceLoc FirstTypeLoc,
+                                             SourceRange CompositionRange);
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::ProtocolComposition;
   }
   static bool classof(const ProtocolCompositionTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const { return ProtocolLoc; }
-  SourceLoc getEndLocImpl() const { return AngleBrackets.End; }
+  SourceLoc getStartLocImpl() const { return FirstTypeLoc; }
+  SourceLoc getEndLocImpl() const { return CompositionRange.End; }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
   friend class TypeRepr;
 };

include/swift/Parse/Parser.h

@@ -414,8 +414,7 @@ class Parser {
   }
 
   SourceLoc consumeIdentifier(Identifier *Result = nullptr) {
-    assert(Tok.is(tok::identifier) || Tok.is(tok::kw_self) ||
-           Tok.is(tok::kw_Self) || Tok.is(tok::kw_throws));
+    assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self, tok::kw_throws));
     if (Result)
       *Result = Context.getIdentifier(Tok.getText());
     return consumeToken();
@@ -877,9 +876,10 @@ class Parser {
   bool parseGenericArguments(SmallVectorImpl<TypeRepr*> &Args,
                              SourceLoc &LAngleLoc,
                              SourceLoc &RAngleLoc);
+
   ParserResult<IdentTypeRepr> parseTypeIdentifier();
+  ParserResult<TypeRepr> parseTypeIdentifierOrTypeComposition();
 
-  ParserResult<ProtocolCompositionTypeRepr> parseTypeComposition();
   ParserResult<TupleTypeRepr> parseTypeTupleBody();
   ParserResult<TypeRepr> parseTypeArray(TypeRepr *Base);
 
@@ -1082,6 +1082,7 @@ class Parser {
 
   bool canParseType();
   bool canParseTypeIdentifier();
+  bool canParseTypeIdentifierOrTypeComposition();
   bool canParseTypeComposition();
   bool canParseTypeTupleBody();
   bool canParseTypeAttribute();

lib/AST/ASTContext.cpp

@@ -423,6 +423,7 @@ ASTContext::ASTContext(LangOptions &langOpts, SearchPathOptions &SearchPathOpts,
     TheUnresolvedType(new (*this, AllocationArena::Permanent)
                       UnresolvedType(*this)),
     TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
+    TheAnyType(ProtocolCompositionType::get(*this, ArrayRef<Type>())),
     TheNativeObjectType(new (*this, AllocationArena::Permanent)
                            BuiltinNativeObjectType(*this)),
     TheBridgeObjectType(new (*this, AllocationArena::Permanent)
@@ -801,26 +802,24 @@ TypeAliasDecl *ASTContext::getVoidDecl() const {
   return Impl.VoidDecl;
 }
 
-
 TypeAliasDecl *ASTContext::getAnyDecl() const {
-  if (Impl.AnyDecl) {
-    return Impl.AnyDecl;
+  if (Impl.VoidDecl) {
+    return Impl.VoidDecl;
   }
 
-  // Go find 'Any' in the Swift module.
+  // 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.AnyDecl = typeAlias;
-      break;
+      Impl.VoidDecl = typeAlias;
+      return typeAlias;
     }
   }
 
-  return Impl.AnyDecl;
+  return Impl.VoidDecl;
 }
 
-
 StructDecl *ASTContext::getObjCBoolDecl() {
   if (!Impl.ObjCBoolDecl) {
     SmallVector<ValueDecl *, 1> results;

lib/AST/TypeRepr.cpp

@@ -210,8 +210,8 @@ TypeRepr *CloneVisitor::visitProtocolCompositionTypeRepr(
   }
 
   return new (Ctx) ProtocolCompositionTypeRepr(protocols,
-                                               T->getProtocolLoc(),
-                                               T->getAngleBrackets());
+                                               T->getStartLoc(),
+                                               T->getCompositionRange());
 }
 
 TypeRepr *CloneVisitor::visitMetatypeTypeRepr(MetatypeTypeRepr *T) {
@@ -426,10 +426,10 @@ void NamedTypeRepr::printImpl(ASTPrinter &Printer,
 ProtocolCompositionTypeRepr *
 ProtocolCompositionTypeRepr::create(ASTContext &C,
                                     ArrayRef<IdentTypeRepr *> Protocols,
-                                    SourceLoc ProtocolLoc,
-                                    SourceRange AngleBrackets) {
+                                    SourceLoc FirstTypeLoc,
+                                    SourceRange CompositionRange) {
   return new (C) ProtocolCompositionTypeRepr(C.AllocateCopy(Protocols),
-                                             ProtocolLoc, AngleBrackets);
+                                             FirstTypeLoc, CompositionRange);
 }
 
 void ProtocolCompositionTypeRepr::printImpl(ASTPrinter &Printer,

lib/ClangImporter/ImportType.cpp

@@ -1599,7 +1599,7 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
   if (isVariadic) {
     auto paramTy =
         BoundGenericType::get(SwiftContext.getArrayDecl(), Type(),
-                              {SwiftContext.getAnyDecl()->getDeclaredType()});
+                              {SwiftContext.TheAnyType});
     auto name = SwiftContext.getIdentifier("varargs");
     auto param = new (SwiftContext)
         ParamDecl(true, SourceLoc(), SourceLoc(), Identifier(), SourceLoc(),

lib/IDE/SyntaxModel.cpp

@@ -92,7 +92,7 @@ SyntaxModelContext::SyntaxModelContext(SourceFile &SrcFile)
         LiteralStartLoc = Optional<SourceLoc>();
         continue;
       }
-
+      
       switch(Tok.getKind()) {
 #define KEYWORD(X) case tok::kw_##X: Kind = SyntaxNodeKind::Keyword; break;
 #include "swift/Parse/Tokens.def"