---

yaml
---
r: 345815
b: refs/heads/master
c: 9b42a82
h: refs/heads/master
i:
  345813: ad93c78
  345811: 2647aff
  345807: c311b29

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b8430af88c4d8cf3081dbcdeca62546fbe5972d3
+refs/heads/master: 9b42a82224c661b4b30adafb71ae2e2dfc5a0ca9
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/lib/AST/Decl.cpp

@@ -3210,6 +3210,7 @@ AssociatedTypeDecl *AssociatedTypeDecl::getAssociatedTypeAnchor() const {
   // Find the best anchor among the anchors of the overridden decls.
   AssociatedTypeDecl *bestAnchor = nullptr;
   for (auto assocType : overridden) {
+    assert(this != assocType && "AssociatedTypeDecl cannot override itself");
     auto anchor = assocType->getAssociatedTypeAnchor();
     if (!bestAnchor || compare(anchor, bestAnchor) < 0)
       bestAnchor = anchor;

trunk/lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -74,11 +74,15 @@ static bool isBarrier(SILInstruction *inst) {
 
     // Whitelist the safe builtin categories. Builtins should generally be
     // treated conservatively, because introducing a new builtin does not
-    // require updating all passes to be aware of it. Avoid a default to ensure
-    // that all categories are covered.
+    // require updating all passes to be aware of it.
     switch (kind.getValue()) {
     case BuiltinValueKind::None:
       llvm_unreachable("Builtin must has a non-empty kind.");
+
+      // Unhandled categories don't generate a case. Instead, they result
+      // in a build error: enumeration values not handled in switch.
+#define BUILTIN(Id, Name, Attrs)
+
 #define BUILTIN_NO_BARRIER(Id)                                                 \
   case BuiltinValueKind::Id:                                                   \
     return false;
@@ -100,7 +104,59 @@ static bool isBarrier(SILInstruction *inst) {
 #define BUILTIN_RUNTIME_CALL(Id, Name, Attrs)                                  \
   case BuiltinValueKind::Id:                                                   \
     return true; // A runtime call could be anything.
-#define BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload) BUILTIN_NO_BARRIER(Id)
+
+    // Handle BUILTIN_MISC_OPERATIONs individually.
+    case BuiltinValueKind::Sizeof:
+    case BuiltinValueKind::Strideof:
+    case BuiltinValueKind::IsPOD:
+    case BuiltinValueKind::IsBitwiseTakable:
+    case BuiltinValueKind::IsSameMetatype:
+    case BuiltinValueKind::Alignof:
+    case BuiltinValueKind::OnFastPath:
+    case BuiltinValueKind::ExtractElement:
+    case BuiltinValueKind::InsertElement:
+    case BuiltinValueKind::StaticReport:
+    case BuiltinValueKind::AssertConf:
+    case BuiltinValueKind::StringObjectOr:
+    case BuiltinValueKind::UToSCheckedTrunc:
+    case BuiltinValueKind::SToUCheckedTrunc:
+    case BuiltinValueKind::SToSCheckedTrunc:
+    case BuiltinValueKind::UToUCheckedTrunc:
+    case BuiltinValueKind::SUCheckedConversion:
+    case BuiltinValueKind::USCheckedConversion:
+    case BuiltinValueKind::IntToFPWithOverflow:
+    case BuiltinValueKind::ZeroInitializer:
+    case BuiltinValueKind::Once:
+    case BuiltinValueKind::OnceWithContext:
+    case BuiltinValueKind::GetObjCTypeEncoding:
+    case BuiltinValueKind::Swift3ImplicitObjCEntrypoint:
+    case BuiltinValueKind::WillThrow:
+      return false;
+
+    // Handle some rare builtins that may be sensitive to object lifetime
+    // or deinit side effects conservatively.
+    case BuiltinValueKind::AllocRaw:
+    case BuiltinValueKind::DeallocRaw:
+    case BuiltinValueKind::Fence:
+    case BuiltinValueKind::AtomicLoad:
+    case BuiltinValueKind::AtomicStore:
+    case BuiltinValueKind::AtomicRMW:
+    case BuiltinValueKind::Unreachable:
+    case BuiltinValueKind::CmpXChg:
+    case BuiltinValueKind::CondUnreachable:
+    case BuiltinValueKind::DestroyArray:
+    case BuiltinValueKind::CopyArray:
+    case BuiltinValueKind::TakeArrayNoAlias:
+    case BuiltinValueKind::TakeArrayFrontToBack:
+    case BuiltinValueKind::TakeArrayBackToFront:
+    case BuiltinValueKind::AssignCopyArrayNoAlias:
+    case BuiltinValueKind::AssignCopyArrayFrontToBack:
+    case BuiltinValueKind::AssignCopyArrayBackToFront:
+    case BuiltinValueKind::AssignTakeArray:
+    case BuiltinValueKind::UnsafeGuaranteed:
+    case BuiltinValueKind::UnsafeGuaranteedEnd:
+      return true;
+
 #define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs) BUILTIN_NO_BARRIER(Id)
 #define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name) BUILTIN_NO_BARRIER(Id)
 #define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name) BUILTIN_NO_BARRIER(Id)

trunk/test/decl/func/operator.swift

@@ -359,3 +359,41 @@ class C6 {
     if x == x && x = x { } // expected-error{{cannot convert value of type 'C6' to expected argument type 'Bool'}}
   }
 }
+
+prefix operator ∫
+
+prefix func ∫(arg: (Int, Int)) {}
+
+func testPrefixOperatorOnTuple() {
+
+  let foo = (1, 2)
+  _ = ∫foo
+  _ = (∫)foo
+  // expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
+  // expected-warning@-2 {{expression of type '(Int, Int)' is unused}}
+  _ = (∫)(foo)
+  _ = ∫(1, 2)
+  _ = (∫)(1, 2) // expected-error {{operator function '∫' expects a single parameter of type '(Int, Int)'}}
+  _ = (∫)((1, 2))
+}
+
+postfix operator §
+
+postfix func §<T, U>(arg: (T, (U, U), T)) {} // expected-note {{in call to operator '§'}}
+
+func testPostfixOperatorOnTuple<A, B>(a: A, b: B) {
+
+  let foo = (a, (b, b), a)
+  _ = foo§
+
+  // FIX-ME: "...could not be inferred" is irrelevant
+  _ = (§)foo
+  // expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
+  // expected-error@-2 {{generic parameter 'T' could not be inferred}}
+  // expected-warning@-3 {{expression of type '(A, (B, B), A)' is unused}}
+  _ = (§)(foo)
+  _ = (a, (b, b), a)§
+  _ = (§)(a, (b, b), a) // expected-error {{operator function '§' expects a single parameter of type '(T, (U, U), T)'}}
+  _ = (§)((a, (b, b), a))
+  _ = (a, ((), (b, (a, a), b)§), a)§
+}