[SE-0095] Code feedback changes; Any is parsed as a keyword

- Any is made into a keyword which is always resolved into a TypeExpr,
allowing the removal of the type system code to find TheAnyType before
an unconstrained lookup.
- Types called `Any` can be declared, they are looked up as any other
identifier is
- Renaming/redefining behaviour of source loc methods on
ProtocolCompositionTypeRepr. Added a createEmptyComposition static
method too.
- Code highlighting treats Any as a type
- simplifyTypeExpr also does not rely on source to get operator name.
- Any is now handled properly in canParseType() which was causing
generic param lists containing ‘Any’ to fail
- The import objc id as Any work has been relying on getting a decl for
the Any type. I fix up the clang importer to use Context.TheAnyType
(instead of getAnyDecl()->getDeclaredType()). When importing the id
typedef, we create a typealias to Any and declare it unavaliable.

Author: joewillsher

CHANGELOG.md

@@ -4,20 +4,20 @@ 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.
+  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>
-```
+  ```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.
+  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:

docs/ABI.rst

@@ -461,7 +461,7 @@ contain the following fields:
   `protocol descriptor`_ records, but are pre-calculated for convenience.
 
 - The **number of protocols** that make up the protocol composition is stored at
-  **offset 2**. For the "any" types ``Any`` or ``Any : Class``, this
+  **offset 2**. For the "any" types ``Any`` or ``Any : class``, this
   is zero. For a single-protocol type ``P``, this is one. For a protocol
   composition type ``P & Q & ...``, this is the number of protocols.
 

include/swift/AST/DiagnosticsParse.def

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

include/swift/AST/DiagnosticsSema.def

@@ -517,7 +517,6 @@ 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 overload type keyword", ())
 
 ERROR(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (Identifier))

include/swift/AST/KnownIdentifiers.def

@@ -25,6 +25,7 @@
 IDENTIFIER(alloc)
 IDENTIFIER(allocWithZone)
 IDENTIFIER(allZeros)
+IDENTIFIER(Any)
 IDENTIFIER(atIndexedSubscript)
 IDENTIFIER_(bridgeToObjectiveC)
 IDENTIFIER_WITH_NAME(code_, "_code")
@@ -60,7 +61,6 @@ IDENTIFIER(RawValue)
 IDENTIFIER(Selector)
 IDENTIFIER(self)
 IDENTIFIER(Self)
-IDENTIFIER(Any)
 IDENTIFIER(setObject)
 IDENTIFIER(simd)
 IDENTIFIER(some)

include/swift/AST/TypeRepr.h

@@ -629,21 +629,27 @@ class ProtocolCompositionTypeRepr : public TypeRepr {
   }
 
   ArrayRef<IdentTypeRepr *> getProtocols() const { return Protocols; }
-  SourceLoc getStartLoc() const { return FirstTypeLoc; }
+  SourceLoc getSourceLoc() const { return FirstTypeLoc; }
   SourceRange getCompositionRange() const { return CompositionRange; }
 
   static ProtocolCompositionTypeRepr *create(ASTContext &C,
                                              ArrayRef<IdentTypeRepr*> Protocols,
                                              SourceLoc FirstTypeLoc,
                                              SourceRange CompositionRange);
-
+  
+  static ProtocolCompositionTypeRepr *createEmptyComposition(ASTContext &C,
+                                                             SourceLoc AnyLoc) {
+    return ProtocolCompositionTypeRepr::create(C, {}, AnyLoc, {AnyLoc, AnyLoc});
+  }
+  
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::ProtocolComposition;
   }
   static bool classof(const ProtocolCompositionTypeRepr *T) { return true; }
 
 private:
   SourceLoc getStartLocImpl() const { return FirstTypeLoc; }
+  SourceLoc getLocImpl() const { return CompositionRange.Start; }
   SourceLoc getEndLocImpl() const { return CompositionRange.End; }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
   friend class TypeRepr;

include/swift/Parse/Parser.h

@@ -877,8 +877,9 @@ class Parser {
                              SourceLoc &LAngleLoc,
                              SourceLoc &RAngleLoc);
 
-  ParserResult<IdentTypeRepr> parseTypeIdentifier();
+  ParserResult<TypeRepr> parseTypeIdentifier();
   ParserResult<TypeRepr> parseTypeIdentifierOrTypeComposition();
+  ParserResult<ProtocolCompositionTypeRepr> parseAnyType();
 
   ParserResult<TupleTypeRepr> parseTypeTupleBody();
   ParserResult<TypeRepr> parseTypeArray(TypeRepr *Base);
@@ -1083,7 +1084,7 @@ class Parser {
   bool canParseType();
   bool canParseTypeIdentifier();
   bool canParseTypeIdentifierOrTypeComposition();
-  bool canParseTypeComposition();
+  bool canParseOldStyleProtocolComposition();
   bool canParseTypeTupleBody();
   bool canParseTypeAttribute();
   bool canParseGenericArguments();

include/swift/Parse/Tokens.def

@@ -128,6 +128,7 @@ STMT_KEYWORD(catch)
 
 // Expression keywords.
 KEYWORD(as)
+KEYWORD(Any)
 KEYWORD(dynamicType)
 KEYWORD(false)
 KEYWORD(is)

lib/AST/Type.cpp

@@ -90,7 +90,7 @@ bool TypeBase::hasReferenceSemantics() {
 }
 
 bool TypeBase::isAny() {
-  return isEqual(getASTContext().getAnyDecl()->getDeclaredType());
+  return isEqual(getASTContext().TheAnyType);
 }
 
 bool TypeBase::isAnyClassReferenceType() {

lib/ClangImporter/ImportDecl.cpp

@@ -1535,7 +1535,22 @@ namespace {
         if (Name.str() == "id" && Impl.SwiftContext.LangOpts.EnableIdAsAny) {
           Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] =
               MappedTypeNameKind::DoNothing;
-          return Impl.SwiftContext.getAnyDecl();
+
+          auto DC = Impl.importDeclContextOf(Decl, importedName.EffectiveContext);
+          if (!DC) return nullptr;
+
+          auto loc = Impl.importSourceLoc(Decl->getLocStart());
+          auto Result = Impl.createDeclWithClangNode<TypeAliasDecl>(
+                          Decl, loc, Name, loc,
+                          TypeLoc::withoutLoc(Impl.SwiftContext.TheAnyType),
+                          /*genericparams*/nullptr, DC);
+
+          auto attr = AvailableAttr::createUnconditional(
+                        Impl.SwiftContext, "'id' is not available in Swift; use 'Any'",
+                        "", UnconditionalAvailabilityKind::UnavailableInSwift);
+
+          Result->getAttrs().add(attr);
+          return Result;
         }
 
         bool IsError;