---

yaml
---
r: 341723
b: refs/heads/rxwei-patch-1
c: a35ee51
h: refs/heads/master
i:
  341721: 0eee893
  341719: 5d98fd0

Author: nkcsgexi

[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: f27ccabdb156fd808cfb774f6e9243b32146109f
+refs/heads/rxwei-patch-1: a35ee51502c887aeb40be85ac9cc39134644440d
 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/ABI/Mangling.rst

@@ -717,7 +717,7 @@ conformance within the witness table, identified by the dependent type and
 protocol. In all cases, the DEPENDENT-CONFORMANCE-INDEX is an INDEX value
 indicating the position of the appropriate value within the generic environment
 (for "HD") or witness table (for "HI" and "HA") when it is known to be at a
-fixed position. An index of 1 ("0_") is used to indicate "unknown"; all other
+fixed position. An index of 1 ("0\_") is used to indicate "unknown"; all other
 values are adjusted by 2. That these indexes are not 0-based is a bug that's
 now codified into the ABI; the index 0 is therefore reserved.
 

branches/rxwei-patch-1/docs/SIL.rst

@@ -5110,13 +5110,15 @@ cond_fail
 `````````
 ::
 
-  sil-instruction ::= 'cond_fail' sil-operand
+  sil-instruction ::= 'cond_fail' sil-operand, string-literal
 
-  cond_fail %0 : $Builtin.Int1
+  cond_fail %0 : $Builtin.Int1, "failure reason"
   // %0 must be of type $Builtin.Int1
 
 This instruction produces a `runtime failure`_ if the operand is one.
 Execution proceeds normally if the operand is zero.
+The second operand is a static failure message, which is displayed by the
+debugger in case the failure is triggered.
 
 Terminators
 ~~~~~~~~~~~

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

@@ -17,6 +17,7 @@
 #ifndef SWIFT_AST_ANYREQUEST_H
 #define SWIFT_AST_ANYREQUEST_H
 
+#include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/TypeID.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
@@ -85,6 +86,9 @@ class AnyRequest {
 
     /// Note that this request is part of a cycle.
     virtual void noteCycleStep(DiagnosticEngine &diags) const = 0;
+
+    /// Retrieve the nearest source location to which this request applies.
+    virtual SourceLoc getNearestLoc() const = 0;
   };
 
   /// Holds a value that can be used as a request input/output.
@@ -125,6 +129,11 @@ class AnyRequest {
     virtual void noteCycleStep(DiagnosticEngine &diags) const override {
       request.noteCycleStep(diags);
     }
+
+    /// Retrieve the nearest source location to which this request applies.
+    virtual SourceLoc getNearestLoc() const override {
+      return request.getNearestLoc();
+    }
   };
 
   /// FIXME: Inefficient. Use the low bits.
@@ -202,6 +211,11 @@ class AnyRequest {
     stored->noteCycleStep(diags);
   }
 
+  /// Retrieve the nearest source location to which this request applies.
+  SourceLoc getNearestLoc() const {
+    return stored->getNearestLoc();
+  }
+
   /// Compare two instances for equality.
   friend bool operator==(const AnyRequest &lhs, const AnyRequest &rhs) {
     if (lhs.storageKind != rhs.storageKind) {

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

@@ -314,10 +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.
-BUILTIN_SIL_OPERATION(CondFail, "condfail", Special)
-
 /// fixLifetime(T) -> ()
 /// Fixes the lifetime of any heap references in a value.
 BUILTIN_SIL_OPERATION(FixLifetime, "fixLifetime", Special)
@@ -404,6 +400,10 @@ BUILTIN_RUNTIME_CALL(IsOptionalType, "isOptional", "")
           BUILTIN(Id, Name, Attrs)
 #endif
 
+/// condfail(Int1, RawPointer) -> ()
+/// Triggers a runtime failure if the condition is true.
+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

@@ -5615,7 +5615,7 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   }
 
   struct BodySynthesizer {
-    void (* Fn)(AbstractFunctionDecl *, void *);
+    std::pair<BraceStmt *, bool> (* Fn)(AbstractFunctionDecl *, void *);
     void *Context;
   };
 
@@ -5748,18 +5748,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// have a body for this function.
   ///
   /// \sa hasBody()
-  BraceStmt *getBody(bool canSynthesize = true) const {
-    if (canSynthesize && getBodyKind() == BodyKind::Synthesize) {
-      const_cast<AbstractFunctionDecl *>(this)->setBodyKind(BodyKind::None);
-      (Synthesizer.Fn)(const_cast<AbstractFunctionDecl *>(this),
-                       Synthesizer.Context);
-    }
-    if (getBodyKind() == BodyKind::Parsed ||
-        getBodyKind() == BodyKind::TypeChecked) {
-      return Body;
-    }
-    return nullptr;
-  }
+  BraceStmt *getBody(bool canSynthesize = true) const;
+
   void setBody(BraceStmt *S, BodyKind NewBodyKind = BodyKind::Parsed) {
     assert(getBodyKind() != BodyKind::Skipped &&
            "cannot set a body if it was skipped");
@@ -5784,8 +5774,12 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   }
 
   /// Note that parsing for the body was delayed.
-  void setBodySynthesizer(void (* fn)(AbstractFunctionDecl *, void *),
-                         void *context = nullptr) {
+  ///
+  /// The function should return the body statement and a flag indicating
+  /// whether that body is already type-checked.
+  void setBodySynthesizer(
+      std::pair<BraceStmt *, bool> (* fn)(AbstractFunctionDecl *, void *),
+      void *context = nullptr) {
     assert(getBodyKind() == BodyKind::None);
     Synthesizer = {fn, context};
     setBodyKind(BodyKind::Synthesize);

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

@@ -540,10 +540,12 @@ namespace swift {
   /// Class responsible for formatting diagnostics and presenting them
   /// to the user.
   class DiagnosticEngine {
+  public:
     /// The source manager used to interpret source locations and
     /// display diagnostics.
     SourceManager &SourceMgr;
 
+  private:
     /// The diagnostic consumer(s) that will be responsible for actually
     /// emitting diagnostics.
     SmallVector<DiagnosticConsumer *, 2> Consumers;

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

@@ -1131,7 +1131,6 @@ class ObjectLiteralExpr final
 
 private:
   Expr *Arg;
-  Expr *SemanticExpr;
   SourceLoc PoundLoc;
   ConcreteDeclRef Initializer;
 
@@ -1181,9 +1180,6 @@ class ObjectLiteralExpr final
     return Bits.ObjectLiteralExpr.HasTrailingClosure;
   }
 
-  Expr *getSemanticExpr() const { return SemanticExpr; }
-  void setSemanticExpr(Expr *expr) { SemanticExpr = expr; }
-
   SourceLoc getSourceLoc() const { return PoundLoc; }
   SourceRange getSourceRange() const { 
     return SourceRange(PoundLoc, Arg->getEndLoc());

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

@@ -113,7 +113,9 @@ namespace detail {
 
   /// Extract the first, nearest source location from a tuple.
   template<unsigned Index, typename ...Types,
-           typename = typename std::enable_if<Index < sizeof...(Types)>::type>
+           typename = typename std::enable_if<sizeof...(Types) - Index
+                                                  ? true
+                                                  : false>::type>
   SourceLoc extractNearestSourceLocTuple(const std::tuple<Types...> &value) {
     SourceLoc loc = maybeExtractNearestSourceLoc(std::get<Index>(value));
     if (loc.isValid())

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

@@ -689,6 +689,28 @@ class LazyStoragePropertyRequest :
   bool isCached() const { return true; }
 };
 
+/// Request to type check the body of the given function.
+///
+/// Produces true if an error occurred, false otherwise.
+/// FIXME: it would be far better to return the type-checked body.
+class TypeCheckFunctionBodyRequest :
+    public SimpleRequest<TypeCheckFunctionBodyRequest,
+                         bool(AbstractFunctionDecl *),
+                         CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool>
+  evaluate(Evaluator &evaluator, AbstractFunctionDecl *func) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

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

@@ -39,4 +39,5 @@ SWIFT_TYPEID(SelfAccessKindRequest)
 SWIFT_TYPEID(IsGetterMutatingRequest)
 SWIFT_TYPEID(IsSetterMutatingRequest)
 SWIFT_TYPEID(OpaqueReadOwnershipRequest)
-SWIFT_TYPEID(LazyStoragePropertyRequest)
+SWIFT_TYPEID(LazyStoragePropertyRequest)
+SWIFT_TYPEID(TypeCheckFunctionBodyRequest)

branches/rxwei-patch-1/include/swift/Basic/NullablePtr.h

@@ -55,9 +55,14 @@ class NullablePtr {
     assert(Ptr && "Pointer wasn't checked for null!");
     return Ptr;
   }
-  
-  T *getPtrOrNull() { return Ptr; }
-  const T *getPtrOrNull() const { return Ptr; }
+
+  T *getPtrOrNull() { return getPtrOr(nullptr); }
+  const T *getPtrOrNull() const { return getPtrOr(nullptr); }
+
+  T *getPtrOr(T *defaultValue) { return Ptr ? Ptr : defaultValue; }
+  const T *getPtrOr(const T *defaultValue) const {
+    return Ptr ? Ptr : defaultValue;
+  }
 
   explicit operator bool() const { return Ptr; }
 

branches/rxwei-patch-1/include/swift/SIL/SILBuilder.h

@@ -1775,15 +1775,15 @@ class SILBuilder {
   //===--------------------------------------------------------------------===//
 
   CondFailInst *createCondFail(SILLocation Loc, SILValue Operand,
-                               bool Inverted = false) {
+                               StringRef Message, bool Inverted = false) {
     if (Inverted) {
       SILType Ty = Operand->getType();
       SILValue True(createIntegerLiteral(Loc, Ty, 1));
       Operand =
           createBuiltinBinaryFunction(Loc, "xor", Ty, Ty, {Operand, True});
     }
-    return insert(new (getModule())
-                      CondFailInst(getSILDebugLocation(Loc), Operand));
+    return insert(CondFailInst::create(getSILDebugLocation(Loc), Operand,
+                                       Message, getModule()));
   }
 
   BuiltinInst *createBuiltinTrap(SILLocation Loc) {

branches/rxwei-patch-1/include/swift/SIL/SILCloner.h

@@ -2447,7 +2447,8 @@ SILCloner<ImplClass>::visitCondFailInst(CondFailInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   recordClonedInstruction(
       Inst, getBuilder().createCondFail(getOpLocation(Inst->getLoc()),
-                                        getOpValue(Inst->getOperand())));
+                                        getOpValue(Inst->getOperand()),
+                                        Inst->getMessage()));
 }
 
 template<typename ImplClass>

branches/rxwei-patch-1/include/swift/SIL/SILInstruction.h

@@ -6715,14 +6715,28 @@ class ProjectExistentialBoxInst
 //===----------------------------------------------------------------------===//
 
 /// Trigger a runtime failure if the given Int1 value is true.
-class CondFailInst
+///
+/// Optionally cond_fail has a static failure message, which is displayed in the debugger in case the failure
+/// is triggered.
+class CondFailInst final
     : public UnaryInstructionBase<SILInstructionKind::CondFailInst,
-                                  NonValueInstruction>
+                                  NonValueInstruction>,
+      private llvm::TrailingObjects<CondFailInst, char>
 {
+  friend TrailingObjects;
   friend SILBuilder;
 
-  CondFailInst(SILDebugLocation DebugLoc, SILValue Operand)
-      : UnaryInstructionBase(DebugLoc, Operand) {}
+  unsigned MessageSize;
+
+  CondFailInst(SILDebugLocation DebugLoc, SILValue Operand, StringRef Message);
+
+  static CondFailInst *create(SILDebugLocation DebugLoc, SILValue Operand,
+                              StringRef Message, SILModule &M);
+
+public:
+  StringRef getMessage() const {
+    return {getTrailingObjects<char>(), MessageSize};
+  }
 };
 
 //===----------------------------------------------------------------------===//

branches/rxwei-patch-1/include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 500; // dependency types for protocols
+const uint16_t SWIFTMODULE_VERSION_MINOR = 501; // cond_fail messages
 
 using DeclIDField = BCFixed<31>;
 

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

@@ -1977,7 +1977,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printArgumentLabels(E->getArgumentLabels());
     OS << "\n";
     printRec(E->getArg());
-    printSemanticExpr(E->getSemanticExpr());
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 

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

@@ -301,7 +301,7 @@ SourceRange AbstractFunctionDeclScope::getChildlessSourceRange() const {
     assert(r.End.isValid());
     return r;
   }
-  return decl->getBody()->getSourceRange();
+  return decl->getBodySourceRange();
 }
 
 SourceRange AbstractFunctionParamsScope::getChildlessSourceRange() const {