---

yaml
---
r: 341973
b: refs/heads/rxwei-patch-1
c: 35e7ab2
h: refs/heads/master
i:
  341971: a3a51f8

Author: shahmishal

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: bd21fb4e659f56671f7ff65a9b2cff7976079691
+refs/heads/rxwei-patch-1: 35e7ab2c9b11351d38ccfaa5772466e3d3b7735f
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/docs/StandardLibraryProgrammersManual.md

@@ -50,19 +50,6 @@ TODO: Should this subsume or link to [AccessControlInStdlib.rst](https://github.
 
 Optionals can be unwrapped with `!`, which triggers a trap on nil. Alternatively, they can be `.unsafelyUnwrapped()`, which will check and trap in debug builds of user code. Internal to the standard library is `._unsafelyUnwrappedUnchecked()` which will only check and trap in debug builds of the standard library itself. These correspond directly with `_precondition`, `_debugPrecondition`, and `_sanityCheck`. See [that section](#precondition) for details.
 
-#### UnsafeBitCast and Casting References
-
-In general `unsafeBitCast` should be avoided because it's correctness relies on subtle assumptions that will never be enforced, and it indicates a bug in Swift's type system that should be fixed. It's less bad for non-pointer trivial types. Pointer casting should go through one of the memory binding API instead as a last resort.
-
-Reference casting is more interesting. References casting can include converting to an Optional reference and converting from a class constrained existential.
-
-The regular `as` operator should be able to convert between reference types with full dynamic checking.
-
-`unsafeDownCast` is just as capable, but is only dynamically checked in debug mode or if the cast requires runtime support.
-
-`_unsafeUncheckedDowncast` is the same but is only dynamically checked in the stdlib asserts build, or if the cast requires runtime support.
-
-`_unsafeReferenceCast` is only dynamically checked if the cast requires runtime support. Additionally, it does not impose any static `AnyObject` constraint on the incoming reference. This is useful in a generic context where the object-ness can be determined dynamically, as done in some bridged containers.
 
 ### Builtins
 

branches/rxwei-patch-1/include/swift/AST/Builtins.def

@@ -314,11 +314,6 @@ BUILTIN_SIL_OPERATION(BeginUnpairedModifyAccess, "beginUnpairedModifyAccess",
 /// be a pointer to an UnsafeValueBuffer that records an in progress access.
 BUILTIN_SIL_OPERATION(EndUnpairedAccess, "endUnpairedAccess", Special)
 
-/// condfail(Int1) -> ()
-/// Triggers a runtime failure if the condition is true.
-/// This builtin is deprecated. Use condfail_message instead.
-BUILTIN_SIL_OPERATION(LegacyCondFail, "condfail", Special)
-
 /// fixLifetime(T) -> ()
 /// Fixes the lifetime of any heap references in a value.
 BUILTIN_SIL_OPERATION(FixLifetime, "fixLifetime", Special)
@@ -405,9 +400,9 @@ BUILTIN_RUNTIME_CALL(IsOptionalType, "isOptional", "")
           BUILTIN(Id, Name, Attrs)
 #endif
 
-/// condfail_message(Int1, RawPointer) -> ()
+/// condfail(Int1, RawPointer) -> ()
 /// Triggers a runtime failure if the condition is true.
-BUILTIN_MISC_OPERATION(CondFailMessage, "condfail_message", "", Special)
+BUILTIN_MISC_OPERATION(CondFail, "condfail", "", Special)
 
 /// Sizeof has type T.Type -> Int
 BUILTIN_MISC_OPERATION(Sizeof, "sizeof", "n", Special)

branches/rxwei-patch-1/include/swift/AST/Decl.h

@@ -4105,20 +4105,7 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// by this protocol.
   const Requirement *RequirementSignature = nullptr;
 
-  /// Returns the cached result of \c requiresClass or \c None if it hasn't yet
-  /// been computed.
-  Optional<bool> getCachedRequiresClass() const {
-    if (Bits.ProtocolDecl.RequiresClassValid)
-      return Bits.ProtocolDecl.RequiresClass;
-
-    return None;
-  }
-
-  /// Caches the result of \c requiresClass
-  void setCachedRequiresClass(bool requiresClass) {
-    Bits.ProtocolDecl.RequiresClassValid = true;
-    Bits.ProtocolDecl.RequiresClass = requiresClass;
-  }
+  bool requiresClassSlow();
 
   bool existentialConformsToSelfSlow();
 
@@ -4133,7 +4120,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   friend class SuperclassDeclRequest;
   friend class SuperclassTypeRequest;
   friend class RequirementSignatureRequest;
-  friend class ProtocolRequiresClassRequest;
   friend class TypeChecker;
 
 public:
@@ -4197,7 +4183,19 @@ class ProtocolDecl final : public NominalTypeDecl {
   }
 
   /// True if this protocol can only be conformed to by class types.
-  bool requiresClass() const;
+  bool requiresClass() const {
+    if (Bits.ProtocolDecl.RequiresClassValid)
+      return Bits.ProtocolDecl.RequiresClass;
+
+    return const_cast<ProtocolDecl *>(this)->requiresClassSlow();
+  }
+
+  /// Specify that this protocol is class-bounded, e.g., because it was
+  /// annotated with the 'class' keyword.
+  void setRequiresClass(bool requiresClass = true) {
+    Bits.ProtocolDecl.RequiresClassValid = true;
+    Bits.ProtocolDecl.RequiresClass = requiresClass;
+  }
 
   /// Determine whether an existential conforming to this protocol can be
   /// matched with a generic type parameter constrained to this protocol.

branches/rxwei-patch-1/include/swift/AST/DiagnosticsCommon.def

@@ -153,12 +153,6 @@ ERROR(circular_class_inheritance,none,
 ERROR(circular_enum_inheritance,none,
       "%0 has a raw type that depends on itself", (Identifier))
 
-ERROR(circular_protocol_def,none,
-      "protocol %0 refines itself", (Identifier))
-
-NOTE(kind_declname_declared_here,none,
-     "%0 %1 declared here", (DescriptiveDeclKind, DeclName))
-
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)
 #  undef DIAG

branches/rxwei-patch-1/include/swift/AST/DiagnosticsParse.def

@@ -762,13 +762,6 @@ ERROR(extra_rbracket,PointsToFirstBadToken,
       "unexpected ']' in type; did you mean to write an array type?", ())
 ERROR(extra_colon,PointsToFirstBadToken,
       "unexpected ':' in type; did you mean to write a dictionary type?", ())
-WARNING(subscript_array_element, none,
-        "unexpected subscript in array literal; did you mean to write two "
-        "separate elements instead?", ())
-NOTE(subscript_array_element_fix_it_add_comma, none, "add a separator between "
-     "the elements", ())
-NOTE(subscript_array_element_fix_it_remove_space, none,
-     "remove the space between the elements to silence this warning", ())
 
 // Tuple Types
 ERROR(expected_rparen_tuple_type_list,none,
@@ -861,8 +854,6 @@ ERROR(expected_parameter_name,PointsToFirstBadToken,
       "expected parameter name followed by ':'", ())
 ERROR(expected_parameter_colon,PointsToFirstBadToken,
       "expected ':' following argument label and parameter name", ())
-ERROR(expected_assignment_instead_of_comparison_operator,none,
-      "expected '=' instead of '==' to assign default value for parameter", ())
 ERROR(missing_parameter_type,PointsToFirstBadToken,
       "parameter requires an explicit type", ())
 ERROR(multiple_parameter_ellipsis,none,

branches/rxwei-patch-1/include/swift/AST/DiagnosticsSema.def

@@ -37,6 +37,8 @@
   DIAG(NOTE,ID,Options,Text,Signature)
 #endif
 
+NOTE(kind_declname_declared_here,none,
+     "%0 %1 declared here", (DescriptiveDeclKind, DeclName))
 NOTE(decl_declared_here,none,
      "%0 declared here", (DeclName))
 NOTE(kind_declared_here,none,
@@ -2035,6 +2037,8 @@ ERROR(typealias_outside_of_protocol,none,
       "type alias %0 can only be used with a concrete type or "
       "generic parameter base", (Identifier))
 
+ERROR(circular_protocol_def,none,
+      "protocol %0 refines itself", (Identifier))
 ERROR(objc_protocol_inherits_non_objc_protocol,none,
       "@objc protocol %0 cannot refine non-@objc protocol %1", (Type, Type))
 

branches/rxwei-patch-1/include/swift/AST/TypeCheckRequests.h

@@ -176,31 +176,6 @@ class IsObjCRequest :
   void cacheResult(bool value) const;
 };
 
-/// Determine whether the given protocol declaration is class-bounded.
-class ProtocolRequiresClassRequest:
-    public SimpleRequest<ProtocolRequiresClassRequest,
-                         bool(ProtocolDecl *),
-                         CacheKind::SeparatelyCached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  llvm::Expected<bool> evaluate(Evaluator &evaluator, ProtocolDecl *decl) const;
-
-public:
-  // Cycle handling.
-  void diagnoseCycle(DiagnosticEngine &diags) const;
-  void noteCycleStep(DiagnosticEngine &diags) const;
-
-  // Separate caching.
-  bool isCached() const { return true; }
-  Optional<bool> getCachedResult() const;
-  void cacheResult(bool value) const;
-};
-
 /// Determine whether the given declaration is 'final'.
 class IsFinalRequest :
     public SimpleRequest<IsFinalRequest,

branches/rxwei-patch-1/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -19,7 +19,6 @@ SWIFT_TYPEID(SuperclassTypeRequest)
 SWIFT_TYPEID(EnumRawTypeRequest)
 SWIFT_TYPEID(OverriddenDeclsRequest)
 SWIFT_TYPEID(IsObjCRequest)
-SWIFT_TYPEID(ProtocolRequiresClassRequest)
 SWIFT_TYPEID(IsFinalRequest)
 SWIFT_TYPEID(IsDynamicRequest)
 SWIFT_TYPEID(RequirementRequest)

branches/rxwei-patch-1/include/swift/Parse/Parser.h

@@ -1435,8 +1435,6 @@ class Parser {
 
   UnresolvedDeclRefExpr *parseExprOperator();
 
-  void validateCollectionElement(ParserResult<Expr> element);
-
   //===--------------------------------------------------------------------===//
   // Statement Parsing
 

branches/rxwei-patch-1/lib/AST/Builtins.cpp

@@ -1035,13 +1035,6 @@ static ValueDecl *getCanBeObjCClassOperation(ASTContext &Context,
   return builder.build(Id);
 }
 
-static ValueDecl *getLegacyCondFailOperation(ASTContext &C, Identifier Id) {
-  // Int1 -> ()
-  auto CondTy = BuiltinIntegerType::get(1, C);
-  auto VoidTy = TupleType::getEmpty(C);
-  return getBuiltinFunction(Id, {CondTy}, VoidTy);
-}
-
 static ValueDecl *getCondFailOperation(ASTContext &C, Identifier Id) {
   // Int1 -> ()
   auto CondTy = BuiltinIntegerType::get(1, C);
@@ -1897,14 +1890,11 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     if (!Types.empty()) return nullptr;
     return getAddressOfOperation(Context, Id);
 
-  case BuiltinValueKind::LegacyCondFail:
-    return getLegacyCondFailOperation(Context, Id);
-
   case BuiltinValueKind::AddressOfBorrow:
     if (!Types.empty()) return nullptr;
     return getAddressOfBorrowOperation(Context, Id);
 
-  case BuiltinValueKind::CondFailMessage:
+  case BuiltinValueKind::CondFail:
     return getCondFailOperation(Context, Id);
 
   case BuiltinValueKind::AssertConf:

branches/rxwei-patch-1/lib/AST/Decl.cpp

@@ -4320,9 +4320,41 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
   });
 }
 
-bool ProtocolDecl::requiresClass() const {
-  return evaluateOrDefault(getASTContext().evaluator,
-    ProtocolRequiresClassRequest{const_cast<ProtocolDecl *>(this)}, false);
+bool ProtocolDecl::requiresClassSlow() {
+  // Set this first to catch (invalid) circular inheritance.
+  Bits.ProtocolDecl.RequiresClassValid = true;
+  Bits.ProtocolDecl.RequiresClass = false;
+
+  // Quick check: @objc protocols require a class.
+  if (isObjC())
+    return Bits.ProtocolDecl.RequiresClass = true;
+
+  // Determine the set of nominal types that this protocol inherits.
+  bool anyObject = false;
+  auto allInheritedNominals =
+    getDirectlyInheritedNominalTypeDecls(this, anyObject);
+
+  // Quick check: do we inherit AnyObject?
+  if (anyObject) {
+    Bits.ProtocolDecl.RequiresClass = true;
+    return true;
+  }
+
+  // Look through all of the inherited nominals for a superclass or a
+  // class-bound protocol.
+  for (const auto found : allInheritedNominals) {
+    // Superclass bound.
+    if (isa<ClassDecl>(found.second))
+      return Bits.ProtocolDecl.RequiresClass = true;
+
+    // A protocol that might be class-constrained;
+    if (auto proto = dyn_cast<ProtocolDecl>(found.second)) {
+      if (proto->requiresClass())
+        return Bits.ProtocolDecl.RequiresClass = true;
+    }
+  }
+
+  return Bits.ProtocolDecl.RequiresClass;
 }
 
 bool ProtocolDecl::requiresSelfConformanceWitnessTable() const {

branches/rxwei-patch-1/lib/AST/TypeCheckRequests.cpp

@@ -185,32 +185,6 @@ void IsObjCRequest::cacheResult(bool value) const {
   decl->setIsObjC(value);
 }
 
-//----------------------------------------------------------------------------//
-// requiresClass computation.
-//----------------------------------------------------------------------------//
-
-void ProtocolRequiresClassRequest::diagnoseCycle(DiagnosticEngine &diags) const {
-  auto decl = std::get<0>(getStorage());
-  diags.diagnose(decl, diag::circular_protocol_def, decl->getName());
-}
-
-void ProtocolRequiresClassRequest::noteCycleStep(DiagnosticEngine &diags) const {
-  auto requirement = std::get<0>(getStorage());
-  diags.diagnose(requirement, diag::kind_declname_declared_here,
-                 DescriptiveDeclKind::Protocol,
-                 requirement->getName());
-}
-
-Optional<bool> ProtocolRequiresClassRequest::getCachedResult() const {
-  auto decl = std::get<0>(getStorage());
-  return decl->getCachedRequiresClass();
-}
-
-void ProtocolRequiresClassRequest::cacheResult(bool value) const {
-  auto decl = std::get<0>(getStorage());
-  decl->setCachedRequiresClass(value);
-}
-
 //----------------------------------------------------------------------------//
 // isFinal computation.
 //----------------------------------------------------------------------------//

branches/rxwei-patch-1/lib/Parse/ParseExpr.cpp

@@ -3447,10 +3447,8 @@ Parser::parseExprCollectionElement(Optional<bool> &isDictionary) {
   if (!isDictionary.hasValue())
     isDictionary = Tok.is(tok::colon);
 
-  if (!*isDictionary) {
-    validateCollectionElement(Element);
+  if (!*isDictionary)
     return Element;
-  }
 
   if (Element.isNull())
     return Element;
@@ -3473,43 +3471,6 @@ Parser::parseExprCollectionElement(Optional<bool> &isDictionary) {
       TupleExpr::createImplicit(Context, {Element.get(), Value.get()}, {}));
 }
 
-/// validateCollectionElement - Check if a given collection element is valid.
-///
-/// At the moment, this checks whether a given collection element is a subscript
-/// expression and whether we're subscripting into an array. If we are, then it
-/// we emit a diagnostic in case it was not something that the user was
-/// expecting.
-///
-/// For example: `let array [ [0, 1] [42] ]`
-void Parser::validateCollectionElement(ParserResult<Expr> element) {
-  if (element.isNull())
-    return;
-
-  auto elementExpr = element.get();
-  if (!isa<SubscriptExpr>(elementExpr))
-    return;
-
-  auto subscriptExpr = cast<SubscriptExpr>(elementExpr);
-  if (!isa<ArrayExpr>(subscriptExpr->getBase()))
-    return;
-
-  auto arrayExpr = cast<ArrayExpr>(subscriptExpr->getBase());
-
-  auto startLocOfSubscript = subscriptExpr->getIndex()->getStartLoc();
-  auto endLocOfArray = arrayExpr->getEndLoc();
-  auto locForEndOfTokenArray = L->getLocForEndOfToken(SourceMgr, endLocOfArray);
-
-  if (locForEndOfTokenArray != startLocOfSubscript) {
-    auto subscriptLoc = subscriptExpr->getLoc();
-    diagnose(subscriptLoc, diag::subscript_array_element)
-        .highlight(subscriptExpr->getSourceRange());
-    diagnose(subscriptLoc, diag::subscript_array_element_fix_it_add_comma)
-        .fixItInsertAfter(endLocOfArray, ",");
-    diagnose(subscriptLoc, diag::subscript_array_element_fix_it_remove_space)
-        .fixItRemoveChars(locForEndOfTokenArray, startLocOfSubscript);
-  }
-}
-
 void Parser::addPatternVariablesToScope(ArrayRef<Pattern *> Patterns) {
   for (Pattern *Pat : Patterns) {
     Pat->forEachVariable([&](VarDecl *VD) {