[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;

lib/ClangImporter/ImportType.cpp

@@ -972,7 +972,7 @@ namespace {
           return {
               proto->getDeclaredType(),
               ImportHint(ImportHint::ObjCBridged,
-                         Impl.SwiftContext.getAnyDecl()->getDeclaredType())};
+                         Impl.SwiftContext.TheAnyType)};
         return {proto->getDeclaredType(), ImportHint::ObjCPointer};
       }
 

lib/IDE/CodeCompletion.cpp

@@ -4652,9 +4652,9 @@ static void addAnyTypeKeyword(CodeCompletionResultSink &Sink) {
   CodeCompletionResultBuilder Builder(
       Sink, CodeCompletionResult::ResultKind::Keyword,
       SemanticContextKind::None, {});
-  // pretend 'Any' is from another module
   Builder.setKeywordKind(CodeCompletionKeywordKind::None);
   Builder.addTextChunk("Any");
+  Builder.addTypeAnnotation("Any");
 }
 
 

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"

lib/IRGen/GenType.cpp

@@ -1657,12 +1657,12 @@ llvm::StructType *IRGenModule::createNominalType(CanType type) {
 llvm::StructType *
 IRGenModule::createNominalType(ProtocolCompositionType *type) {
   llvm::SmallString<32> typeName;
-  
+
   SmallVector<ProtocolDecl *, 4> protocols;
   type->getAnyExistentialTypeProtocols(protocols);
 
   if (protocols.empty()) {
-    typeName.append("swift.Any");
+    typeName.append("Any");
   } else {
     for (unsigned i = 0, e = protocols.size(); i != e; ++i) {
       if (i) typeName.push_back('&');

lib/Parse/ParseDecl.cpp

@@ -2433,38 +2433,43 @@ ParserStatus Parser::parseInheritance(SmallVectorImpl<TypeLoc> &Inherited,
       continue;
     }
 
-    auto usesDeprecatedCompositionSyntax = Tok.is(tok::kw_protocol) && startsWithLess(peekToken());
-    
+    bool usesDeprecatedCompositionSyntax = Tok.is(tok::kw_protocol) && startsWithLess(peekToken());
+    bool isAny = Tok.is(tok::kw_Any); // We allow (redundant) inheritance from Any
+
     auto ParsedTypeResult = parseTypeIdentifierOrTypeComposition();
     Status |= ParsedTypeResult;
-    
-    // cannot inherit from composition
+
+    // 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());
-      if (usesDeprecatedCompositionSyntax) {
-        // Provide fixits to remove the composition, leaving the types intact.
-        auto compositionRange = Composition->getCompositionRange();
-        diagnose(Composition->getStartLoc(),
-                 diag::disallowed_protocol_composition)
-          .highlight({Composition->getStartLoc(), compositionRange.End})
-          .fixItRemove({Composition->getStartLoc(), compositionRange.Start})
-          .fixItRemove(startsWithGreater(L->getTokenAt(compositionRange.End))
-                     ? compositionRange.End
-                     : SourceLoc());
-      } else {
-        diagnose(Composition->getStartLoc(),
-                 diag::disallowed_protocol_composition)
-          .highlight(Composition->getCompositionRange());
-        // TODO: Decompose 'A & B & C' list to 'A, B, C'
+      // We can inherit from Any
+      if (!isAny) {
+        if (usesDeprecatedCompositionSyntax) {
+          // Provide fixits to remove the composition, leaving the types intact.
+          auto compositionRange = Composition->getCompositionRange();
+          diagnose(Composition->getSourceLoc(),
+                   diag::disallowed_protocol_composition)
+            .highlight({Composition->getStartLoc(), compositionRange.End})
+            .fixItRemove({Composition->getSourceLoc(), compositionRange.Start})
+            .fixItRemove(startsWithGreater(L->getTokenAt(compositionRange.End))
+                         ? compositionRange.End
+                         : SourceLoc());
+        } else {
+          diagnose(Composition->getStartLoc(),
+                   diag::disallowed_protocol_composition)
+            .highlight(Composition->getSourceRange());
+          // TODO: Decompose 'A & B & C' list to 'A, B, C'
+        }
       }
-    } else {
-      // Record the type if its a single type.
-      if (ParsedTypeResult.isNonNull())
-        Inherited.push_back(ParsedTypeResult.get());
+      continue;
     }
 
+    // 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/ParseExpr.cpp

@@ -1176,6 +1176,14 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
     }
 
     break;
+
+  case tok::kw_Any: { // Any
+    ParserResult<TypeRepr> repr = parseAnyType();
+    auto expr = new (Context) TypeExpr(TypeLoc(repr.get()));
+    Result = makeParserResult(expr);
+    break;
+  }
+
   case tok::dollarident: // $1
     Result = makeParserResult(parseExprAnonClosureArg());
     break;

lib/Parse/ParseGeneric.cpp

@@ -70,7 +70,7 @@ Parser::parseGenericParameters(SourceLoc LAngleLoc) {
       (void)consumeToken();
       ParserResult<TypeRepr> Ty;
 
-      if (Tok.isAny(tok::identifier, tok::code_complete, tok::kw_protocol)) {
+      if (Tok.isAny(tok::identifier, tok::code_complete, tok::kw_protocol, tok::kw_Any)) {
         Ty = parseTypeIdentifierOrTypeComposition();
       } else if (Tok.is(tok::kw_class)) {
         diagnose(Tok, diag::unexpected_class_constraint);