---

yaml
---
r: 344027
b: refs/heads/master-rebranch
c: 7814fdb
h: refs/heads/master
i:
  344025: 9a20002
  344023: 964f1a9

Author: theblixguy

[refs]

@@ -1455,7 +1455,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: b3d3ef3867854cc9e82102b1054539553b88833b
+refs/heads/master-rebranch: 7814fdb899d96b4da83ff374d9e71608767d89b3
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec

branches/master-rebranch/CHANGELOG.md

@@ -26,6 +26,63 @@ CHANGELOG
 Swift Next
 ----------
 
+* [SR-11298][]:
+
+  A class-constrained protocol extension, where the extended protocol does
+  not impose a class constraint, will now infer the constraint implicitly.
+
+  ```swift
+  protocol Foo {}
+  class Bar: Foo {
+    var someProperty: Int = 0
+  }
+
+  // Even though 'Foo' does not impose a class constraint, it is automatically
+  // inferred due to the Self: Bar constraint.
+  extension Foo where Self: Bar {
+    var anotherProperty: Int {
+      get { return someProperty }
+      // As a result, the setter is now implicitly nonmutating, just like it would
+      // be if 'Foo' had a class constraint.
+      set { someProperty = newValue }
+    }
+  }
+  ```
+  
+  As a result, this could lead to code that currently compiles today to throw an error.
+  
+  ```swift
+  protocol Foo {
+    var someProperty: Int { get set }
+  }
+  
+  class Bar: Foo {
+    var someProperty = 0
+  }
+  
+  extension Foo where Self: Bar {
+    var anotherProperty1: Int {
+      get { return someProperty }
+      // This will now error, because the protocol requirement
+      // is implicitly mutating and the setter is implicitly 
+      // nonmutating.
+      set { someProperty = newValue } // Error
+    }
+  }
+  ```
+
+  **Workaround**: Define a new mutable variable inside the setter that has a reference to `self`:
+  
+  ```swift
+  var anotherProperty1: Int {
+    get { return someProperty }
+    set {
+      var mutableSelf = self
+      mutableSelf.someProperty = newValue // Okay
+    }
+  }
+```
+
 * [SE-0253][]:
 
   Values of types that declare `func callAsFunction` methods can be called
@@ -51,7 +108,7 @@ Swift Next
 
 * [SR-4206][]:
 
-  A method override is no longer allowed to have a generic signature with 
+  A method override is no longer allowed to have a generic signature with
   requirements not imposed by the base method. For example:
 
   ```
@@ -7765,3 +7822,4 @@ Swift 1.0
 [SR-8974]: <https://bugs.swift.org/browse/SR-8974>
 [SR-9043]: <https://bugs.swift.org/browse/SR-9043>
 [SR-9827]: <https://bugs.swift.org/browse/SR-9827>
+[SR-11298]: <https://bugs.swift.org/browse/SR-11298>

branches/master-rebranch/include/swift/AST/Builtins.def

@@ -75,6 +75,8 @@ BUILTIN_BINARY_OPERATION(ExactUDiv, "udiv_exact", "n", IntegerOrVector)
 BUILTIN_BINARY_OPERATION(URem,    "urem",     "n", Integer)
 BUILTIN_BINARY_OPERATION(FRem,    "frem",     "n", FloatOrVector)
 BUILTIN_BINARY_OPERATION(Xor,     "xor",      "n", IntegerOrVector)
+// This builtin is an optimizer hint and always returns the first argument.
+BUILTIN_BINARY_OPERATION(Expect, "int_expect", "n", Integer)
 #undef BUILTIN_BINARY_OPERATION
 
 /// These builtins are analogous the similarly named llvm intrinsics. The

branches/master-rebranch/include/swift/AST/DeclContext.h

@@ -261,7 +261,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
 
   /// Returns the kind of context this is.
   DeclContextKind getContextKind() const;
-  
+
+  /// Returns whether this context has value semantics.
+  bool hasValueSemantics() const;
+
   /// Determines whether this context is itself a local scope in a
   /// code block.  A context that appears in such a scope, like a
   /// local type declaration, does not itself become a local context.

branches/master-rebranch/include/swift/AST/DiagnosticsSIL.def

@@ -360,61 +360,75 @@ ERROR(pound_assert_failure,none,
 NOTE(constexpr_unknown_reason_default,none,
     "cannot evaluate expression as constant here", ())
 NOTE(constexpr_unevaluable_operation,none,
-    "cannot constant evaluate operation", ())
+    "cannot constant evaluate operation%select{| used by this call}0", (bool))
 
 NOTE(constexpr_too_many_instructions,none,
      "exceeded instruction limit: %0 when evaluating the expression "
      "at compile time", (unsigned))
-NOTE(constexpr_limit_exceeding_instruction,none, "limit exceeded here", ())
+NOTE(constexpr_limit_exceeding_instruction,none, "limit exceeded "
+     "%select{here|during this call}0", (bool))
 
 NOTE(constexpr_loop_found_note,none,
     "control-flow loop found during evaluation ", ())
-NOTE(constexpr_loop_instruction,none, "found loop here", ())
+NOTE(constexpr_loop_instruction,none, "found loop "
+    "%select{here|inside this call}0", (bool))
 
 NOTE(constexpr_overflow,none, "integer overflow detected", ())
-NOTE(constexpr_overflow_operation,none, "operation overflows", ())
+NOTE(constexpr_overflow_operation,none, "operation"
+     "%select{| performed during this call}0 overflows", (bool))
 
 NOTE(constexpr_trap,none, "trap detected", ())
-NOTE(constexpr_trap_operation,none, "operation traps", ())
+NOTE(constexpr_trap_operation,none, "operation"
+     "%select{| performed during this call}0 traps", (bool))
+
+NOTE(constexpr_assertion_failed, none, "assertion failed with message: %0",
+    (StringRef))
+NOTE(constexpr_assertion_failed_here, none, "assertion failed"
+     "%select{ here| during this call}0 ", (bool))
 
 NOTE(constexpr_invalid_operand_seen, none,
     "operation with invalid operands encountered during evaluation",())
 NOTE(constexpr_operand_invalid_here, none,
-    "operation with invalid operands encountered here",())
+    "operation with invalid operands encountered "
+    "%select{here|during this call}0", (bool))
 
 NOTE(constexpr_value_unknown_at_top_level,none,
     "cannot evaluate top-level value as constant here",())
 NOTE(constexpr_multiple_writers_found_at_top_level,none,
      "top-level value has multiple assignments",())
 
 NOTE(constexpr_unsupported_instruction_found, none,
-    "encountered operation not supported by the evaluator", ())
-NOTE(constexpr_unsupported_instruction_found_here,none,
-    "operation not supported by the evaluator", ())
+    "encountered operation not supported by the evaluator: %0", (StringRef))
+NOTE(constexpr_unsupported_instruction_found_here,none, "operation"
+     "%select{| used by this call is}0 not supported by the evaluator", (bool))
 
 NOTE(constexpr_unknown_function_called, none,
-    "encountered call to a function whose body is not available", ())
+    "encountered call to '%0' whose body is not available", (StringRef))
 NOTE(constexpr_unknown_function_called_here, none,
-    "call to a function whose body is not available", ())
+    "%select{|calls a }0function whose body is not available", (bool))
 
 NOTE(constexpr_untracked_sil_value_use_found, none,
     "encountered use of a variable not tracked by the evaluator", ())
 NOTE(constexpr_untracked_sil_value_used_here, none,
-    "untracked variable used here", ())
-
-NOTE(constexpr_witness_call_with_no_conformance_found, none,
-    "cannot find concrete conformance for a witness method call", ())
-NOTE(constexpr_witness_call_with_no_target_found, none,
-    "cannot resolve a witness method call to a concrete function", ())
-NOTE(constexpr_witness_call_found_here, none,
-    "witness method call found here", ())
+    "untracked variable used %select{here|by this call}0", (bool))
+
+NOTE(constexpr_unresolvable_witness_call, none,
+    "encountered unresolvable witness method call: '%0'", (StringRef))
+NOTE(constexpr_no_witness_table_entry, none, "cannot find witness table entry "
+    "%select{for this call|for a witness-method invoked during this call}0",
+    (bool))
+NOTE(constexpr_witness_call_with_no_conformance, none,
+    "cannot find concrete conformance "
+    "%select{for this call|for a witness-method invoked during this call}0",
+    (bool))
 
 NOTE(constexpr_unknown_control_flow_due_to_skip,none, "branch depends on "
      "non-constant value produced by an unevaluated instructions", ())
 NOTE(constexpr_returned_by_unevaluated_instruction,none,
      "return value of an unevaluated instruction is not a constant", ())
 NOTE(constexpr_mutated_by_unevaluated_instruction,none, "value mutable by an "
     "unevaluated instruction is not a constant", ())
+ERROR(not_constant_evaluable, none, "not constant evaluable", ())
 
 ERROR(non_physical_addressof,none,
       "addressof only works with purely physical lvalues; "

branches/master-rebranch/include/swift/SIL/OwnershipUtils.h

@@ -170,6 +170,18 @@ class LinearLifetimeChecker {
              ArrayRef<BranchPropagatedUser> nonConsumingUses,
              ownership::ErrorBehaviorKind errorBehavior,
              SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
+
+  /// Returns true that \p value forms a linear lifetime with consuming uses \p
+  /// consumingUses, non consuming uses \p nonConsumingUses. Returns false
+  /// otherwise.
+  bool validateLifetime(SILValue value,
+                        ArrayRef<BranchPropagatedUser> consumingUses,
+                        ArrayRef<BranchPropagatedUser> nonConsumingUses) {
+    return !checkValue(value, consumingUses, nonConsumingUses,
+                       ownership::ErrorBehaviorKind::ReturnFalse,
+                       nullptr /*leakingBlocks*/)
+                .getFoundError();
+  }
 };
 
 /// Returns true if v is an address or trivial.

branches/master-rebranch/include/swift/SIL/SILConstants.h

@@ -41,63 +41,119 @@ extern llvm::cl::opt<unsigned> ConstExprLimit;
 /// allowing the caller to produce a specific diagnostic.  The "Unknown"
 /// SymbolicValue representation also includes a pointer to the SILNode in
 /// question that was problematic.
-enum class UnknownReason {
-  // TODO: Eliminate the default code, by making classifications for each
-  // failure mode.
-  Default,
+class UnknownReason {
+public:
+  enum UnknownKind {
+    // TODO: Eliminate the default kind, by making classifications for each
+    // failure mode.
+    Default,
+
+    /// The constant expression was too big.  This is reported on a random
+    /// instruction within the constexpr that triggered the issue.
+    TooManyInstructions,
+
+    /// A control flow loop was found.
+    Loop,
+
+    /// Integer overflow detected.
+    Overflow,
+
+    /// Unspecified trap detected.
+    Trap,
+
+    /// Assertion failure detected. These have an associated message unlike
+    /// traps.
+    AssertionFailure,
 
-  /// The constant expression was too big.  This is reported on a random
-  /// instruction within the constexpr that triggered the issue.
-  TooManyInstructions,
+    /// An operation was applied over operands whose symbolic values were
+    /// constants but were not valid for the operation.
+    InvalidOperandValue,
 
-  /// A control flow loop was found.
-  Loop,
+    /// Encountered an instruction not supported by the interpreter.
+    UnsupportedInstruction,
 
-  /// Integer overflow detected.
-  Overflow,
+    /// Encountered a function call where the body of the called function is
+    /// not available.
+    CalleeImplementationUnknown,
 
-  /// Unspecified trap detected.
-  Trap,
+    /// Attempted to load from/store into a SIL value that was not tracked by
+    /// the interpreter.
+    UntrackedSILValue,
 
-  /// An operation was applied over operands whose symbolic values were
-  /// constants but were not valid for the operation.
-  InvalidOperandValue,
+    /// Attempted to find a concrete protocol conformance for a witness method
+    /// and failed.
+    UnknownWitnessMethodConformance,
 
-  /// Encountered an instruction not supported by the interpreter.
-  UnsupportedInstruction,
+    /// Attempted to determine the SIL function of a witness method  and failed.
+    NoWitnesTableEntry,
 
-  /// Encountered a function call where the body of the called function is
-  /// not available.
-  CalleeImplementationUnknown,
+    /// The value of a top-level variable cannot be determined to be a constant.
+    /// This is only relevant in the backward evaluation mode, which is used by
+    /// #assert.
+    NotTopLevelConstant,
 
-  /// Attempted to load from/store into a SIL value that was not tracked by
-  /// the interpreter.
-  UntrackedSILValue,
+    /// A top-level value has multiple writers. This is only relevant in the
+    /// non-flow-sensitive evaluation mode,  which is used by #assert.
+    MutipleTopLevelWriters,
 
-  /// Attempted to find a concrete protocol conformance for a witness method
-  /// and failed.
-  UnknownWitnessMethodConformance,
+    /// Indicates the return value of an instruction that was not evaluated
+    /// during interpretation.
+    ReturnedByUnevaluatedInstruction,
 
-  /// Attempted to determine the SIL function of a witness method (based on a
-  /// concrete protocol conformance) and failed.
-  UnresolvableWitnessMethod,
+    /// Indicates that the value was possibly modified by an instruction
+    /// that was not evaluated during the interpretation.
+    MutatedByUnevaluatedInstruction,
+  };
 
-  /// The value of a top-level variable cannot be determined to be a constant.
-  /// This is only relevant in the backward evaluation mode, which is used by
-  /// #assert.
-  NotTopLevelConstant,
+private:
+  UnknownKind kind;
 
-  /// A top-level value has multiple writers. This is only relevant in the
-  /// non-flow-sensitive evaluation mode,  which is used by #assert.
-  MutipleTopLevelWriters,
+  // Auxiliary information for different unknown kinds.
+  union {
+    SILFunction *function;
+    const char *failedAssertMessage;
+  } payload;
 
-  /// Indicates the return value of an instruction that was not evaluated during
-  /// interpretation.
-  ReturnedByUnevaluatedInstruction,
+public:
+  UnknownKind getKind() { return kind; }
 
-  /// Indicates that the value was possibly modified by an instruction
-  /// that was not evaluated during the interpretation.
-  MutatedByUnevaluatedInstruction,
+  static bool isUnknownKindWithPayload(UnknownKind kind) {
+    return kind == UnknownKind::CalleeImplementationUnknown;
+  }
+
+  static UnknownReason create(UnknownKind kind) {
+    assert(!isUnknownKindWithPayload(kind));
+    UnknownReason reason;
+    reason.kind = kind;
+    return reason;
+  }
+
+  static UnknownReason createCalleeImplementationUnknown(SILFunction *callee) {
+    assert(callee);
+    UnknownReason reason;
+    reason.kind = UnknownKind::CalleeImplementationUnknown;
+    reason.payload.function = callee;
+    return reason;
+  }
+
+  SILFunction *getCalleeWithoutImplmentation() {
+    assert(kind == UnknownKind::CalleeImplementationUnknown);
+    return payload.function;
+  }
+
+  static UnknownReason createAssertionFailure(const char *message,
+                                              size_t size) {
+    assert(message[size] == '\0' && "message must be null-terminated");
+    UnknownReason reason;
+    reason.kind = UnknownKind::AssertionFailure;
+    reason.payload.failedAssertMessage = message;
+    return reason;
+  }
+
+  const char *getAssertionFailureMessage() {
+    assert(kind == UnknownKind::AssertionFailure);
+    return payload.failedAssertMessage;
+  }
 };
 
 /// An abstract class that exposes functions for allocating symbolic values.
@@ -241,9 +297,6 @@ class SymbolicValue {
   RepresentationKind representationKind : 8;
 
   union {
-    /// This is the reason code for RK_Unknown values.
-    UnknownReason unknownReason : 32;
-
     /// This is the number of bits in an RK_Integer or RK_IntegerInline
     /// representation, which makes the number of entries in the list derivable.
     unsigned integerBitwidth;