---

yaml
---
r: 341715
b: refs/heads/rxwei-patch-1
c: bfae015
h: refs/heads/master
i:
  341713: c476b54
  341711: 5be83fe

Author: gmittert

[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: ca1e808bde54310d0a2e7160ff1375507fd0101c
+refs/heads/rxwei-patch-1: bfae01547f78220b0647b2f39c0d8bec51cc4c59
 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,15 +5110,13 @@ cond_fail
 `````````
 ::
 
-  sil-instruction ::= 'cond_fail' sil-operand, string-literal
+  sil-instruction ::= 'cond_fail' sil-operand
 
-  cond_fail %0 : $Builtin.Int1, "failure reason"
+  cond_fail %0 : $Builtin.Int1
   // %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/Builtins.def

@@ -314,6 +314,10 @@ 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)
@@ -400,10 +404,6 @@ 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 {
-    std::pair<BraceStmt *, bool> (* Fn)(AbstractFunctionDecl *, void *);
+    void (* Fn)(AbstractFunctionDecl *, void *);
     void *Context;
   };
 
@@ -5748,8 +5748,18 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// have a body for this function.
   ///
   /// \sa hasBody()
-  BraceStmt *getBody(bool canSynthesize = true) const;
-
+  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;
+  }
   void setBody(BraceStmt *S, BodyKind NewBodyKind = BodyKind::Parsed) {
     assert(getBodyKind() != BodyKind::Skipped &&
            "cannot set a body if it was skipped");
@@ -5774,12 +5784,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   }
 
   /// Note that parsing for the body was delayed.
-  ///
-  /// 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) {
+  void setBodySynthesizer(void (* fn)(AbstractFunctionDecl *, void *),
+                         void *context = nullptr) {
     assert(getBodyKind() == BodyKind::None);
     Synthesizer = {fn, context};
     setBodyKind(BodyKind::Synthesize);

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

@@ -55,14 +55,9 @@ class NullablePtr {
     assert(Ptr && "Pointer wasn't checked for null!");
     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;
-  }
+  
+  T *getPtrOrNull() { return Ptr; }
+  const T *getPtrOrNull() const { return Ptr; }
 
   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,
-                               StringRef Message, bool Inverted = false) {
+                               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(CondFailInst::create(getSILDebugLocation(Loc), Operand,
-                                       Message, getModule()));
+    return insert(new (getModule())
+                      CondFailInst(getSILDebugLocation(Loc), Operand));
   }
 
   BuiltinInst *createBuiltinTrap(SILLocation Loc) {

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

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

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

@@ -6715,28 +6715,14 @@ class ProjectExistentialBoxInst
 //===----------------------------------------------------------------------===//
 
 /// Trigger a runtime failure if the given Int1 value is true.
-///
-/// Optionally cond_fail has a static failure message, which is displayed in the debugger in case the failure
-/// is triggered.
-class CondFailInst final
+class CondFailInst
     : public UnaryInstructionBase<SILInstructionKind::CondFailInst,
-                                  NonValueInstruction>,
-      private llvm::TrailingObjects<CondFailInst, char>
+                                  NonValueInstruction>
 {
-  friend TrailingObjects;
   friend SILBuilder;
 
-  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};
-  }
+  CondFailInst(SILDebugLocation DebugLoc, SILValue Operand)
+      : UnaryInstructionBase(DebugLoc, Operand) {}
 };
 
 //===----------------------------------------------------------------------===//

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 = 501; // cond_fail messages
+const uint16_t SWIFTMODULE_VERSION_MINOR = 500; // dependency types for protocols
 
 using DeclIDField = BCFixed<31>;
 

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

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

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

@@ -2471,48 +2471,44 @@ class Verifier : public ASTWalker {
             Out << "property getter has parameters\n";
             abort();
           }
-          if (getter->hasInterfaceType()) {
-            Type getterResultType = getter->getResultInterfaceType();
-            getterResultType =
-                var->getDeclContext()->mapTypeIntoContext(getterResultType);
-            if (!getterResultType->isEqual(typeForAccessors)) {
-              Out << "property and getter have mismatched types: '";
-              typeForAccessors.print(Out);
-              Out << "' vs. '";
-              getterResultType.print(Out);
-              Out << "'\n";
-              abort();
-            }
+          Type getterResultType = getter->getResultInterfaceType();
+          getterResultType =
+              var->getDeclContext()->mapTypeIntoContext(getterResultType);
+          if (!getterResultType->isEqual(typeForAccessors)) {
+            Out << "property and getter have mismatched types: '";
+            typeForAccessors.print(Out);
+            Out << "' vs. '";
+            getterResultType.print(Out);
+            Out << "'\n";
+            abort();
           }
         }
       }
 
       if (const FuncDecl *setter = var->getSetter()) {
-        if (setter->hasInterfaceType()) {
-          if (!setter->getResultInterfaceType()->isVoid()) {
-            Out << "property setter has non-Void result type\n";
-            abort();
-          }
-          if (setter->getParameters()->size() == 0) {
-            Out << "property setter has no parameters\n";
-            abort();
-          }
-          if (setter->getParameters()->size() != 1) {
-            Out << "property setter has 2+ parameters\n";
+        if (!setter->getResultInterfaceType()->isVoid()) {
+          Out << "property setter has non-Void result type\n";
+          abort();
+        }
+        if (setter->getParameters()->size() == 0) {
+          Out << "property setter has no parameters\n";
+          abort();
+        }
+        if (setter->getParameters()->size() != 1) {
+          Out << "property setter has 2+ parameters\n";
+          abort();
+        }
+        const ParamDecl *param = setter->getParameters()->get(0);
+        Type paramType = param->getInterfaceType();
+        if (!var->getDeclContext()->contextHasLazyGenericEnvironment()) {
+          paramType = var->getDeclContext()->mapTypeIntoContext(paramType);
+          if (!paramType->isEqual(typeForAccessors)) {
+            Out << "property and setter param have mismatched types:\n";
+            typeForAccessors.dump(Out, 2);
+            Out << "vs.\n";
+            paramType.dump(Out, 2);
             abort();
           }
-          const ParamDecl *param = setter->getParameters()->get(0);
-          Type paramType = param->getInterfaceType();
-          if (!var->getDeclContext()->contextHasLazyGenericEnvironment()) {
-            paramType = var->getDeclContext()->mapTypeIntoContext(paramType);
-            if (!paramType->isEqual(typeForAccessors)) {
-              Out << "property and setter param have mismatched types:\n";
-              typeForAccessors.dump(Out, 2);
-              Out << "vs.\n";
-              paramType.dump(Out, 2);
-              abort();
-            }
-          }
         }
       }
 
@@ -3014,16 +3010,6 @@ class Verifier : public ASTWalker {
     void verifyChecked(AbstractFunctionDecl *AFD) {
       PrettyStackTraceDecl debugStack("verifying AbstractFunctionDecl", AFD);
 
-      if (!AFD->hasValidSignature()) {
-        if (isa<AccessorDecl>(AFD) && AFD->isImplicit())
-          return;
-
-        Out << "All functions except implicit accessors should be "
-               "validated by now\n";
-        AFD->dump(Out);
-        abort();
-      }
-
       // If this function is generic or is within a generic context, it should
       // have an interface type.
       if (AFD->isGenericContext() !=

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

@@ -1037,9 +1037,8 @@ static ValueDecl *getCanBeObjCClassOperation(ASTContext &Context,
 static ValueDecl *getCondFailOperation(ASTContext &C, Identifier Id) {
   // Int1 -> ()
   auto CondTy = BuiltinIntegerType::get(1, C);
-  auto MsgTy = C.TheRawPointerType;
   auto VoidTy = TupleType::getEmpty(C);
-  return getBuiltinFunction(Id, {CondTy, MsgTy}, VoidTy);
+  return getBuiltinFunction(Id, {CondTy}, VoidTy);
 }
 
 static ValueDecl *getAssertConfOperation(ASTContext &C, Identifier Id) {