---

yaml
---
r: 326135
b: refs/heads/master-next
c: 29044e5
h: refs/heads/master
i:
  326133: dbbcd6a
  326131: 73990fe
  326127: accb19a

Author: hborla

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: 85e6f73b1f40c27e96e34bed52d783259c040e0e
+refs/heads/master-next: 29044e5d34fb9034424a13b2bdbf99e604e44f4b
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/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-next/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-next/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-next/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; "