---

yaml
---
r: 346879
b: refs/heads/master
c: 6d8322c
h: refs/heads/master
i:
  346877: 582b64e
  346875: bab42c8
  346871: d66efac
  346863: 944dd1d
  346847: 2c3c2d2
  346815: 1d81141
  346751: 0c9bc8a
  346623: c66eaba

Author: swift-ci

[refs]

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

trunk/lib/Sema/CSDiagnostics.cpp

@@ -86,7 +86,9 @@ Expr *FailureDiagnostic::findParentExpr(Expr *subExpr) const {
 }
 
 Type RequirementFailure::getOwnerType() const {
-  return getType(getAnchor())->getInOutObjectType()->getMetatypeInstanceType();
+  return getType(getRawAnchor())
+      ->getInOutObjectType()
+      ->getMetatypeInstanceType();
 }
 
 const GenericContext *RequirementFailure::getGenericContext() const {

trunk/lib/Sema/CSDiagnostics.h

@@ -203,7 +203,7 @@ class RequirementFailure : public FailureDiagnostic {
     if (!expr)
       return;
 
-    if (auto *parentExpr = findParentExpr(getAnchor()))
+    if (auto *parentExpr = findParentExpr(getRawAnchor()))
       Apply = dyn_cast<ApplyExpr>(parentExpr);
   }
 
@@ -254,12 +254,31 @@ class RequirementFailure : public FailureDiagnostic {
     if (isConditional())
       return true;
 
+    auto *anchor = getAnchor();
+    // In the situations like this:
+    //
+    // ```swift
+    // enum E<T: P> { case foo(T) }
+    // let _: E = .foo(...)
+    // ```
+    //
+    // `E` is going to be opened twice. First, when
+    // it's used as a contextual type, and when `E.foo`
+    // is found and its function type is opened.
+    // We still want to record both fixes but should
+    // avoid diagnosing the same problem multiple times.
+    if (isa<UnresolvedMemberExpr>(anchor)) {
+      auto path = getLocator()->getPath();
+      if (path.front().getKind() != ConstraintLocator::UnresolvedMember)
+        return false;
+    }
+
     // For static/initializer calls there is going to be
     // a separate fix, attached to the argument, which is
     // much easier to diagnose.
     // For operator calls we can't currently produce a good
     // diagnostic, so instead let's refer to expression diagnostics.
-    return !(Apply && (isOperator(Apply) || isa<TypeExpr>(getAnchor())));
+    return !(Apply && (isOperator(Apply) || isa<TypeExpr>(anchor)));
   }
 
   static bool isOperator(const ApplyExpr *apply) {

trunk/lib/Sema/CSSimplify.cpp

@@ -1612,29 +1612,22 @@ static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
   if (type1->hasDependentMember() || type2->hasDependentMember())
     return nullptr;
 
-  auto reqPath = path.take_back(2);
-  auto req = reqPath.back();
-
-  ConstraintLocator *reqLoc = nullptr;
+  auto req = path.back();
   if (req.isConditionalRequirement()) {
     // path is - ... -> open generic -> type req # -> cond req #,
     // to identify type requirement we only need `open generic -> type req #`
     // part, because that's how fixes for type requirements are recorded.
-    reqPath = path.drop_back().take_back(2);
+    auto reqPath = path.drop_back();
     // If underlying conformance requirement has been fixed,
     // then there is no reason to fix up conditional requirements.
     if (cs.hasFixFor(cs.getConstraintLocator(anchor, reqPath,
                                              /*summaryFlags=*/0)))
       return nullptr;
-
-    // For conditional requirements we need a full path.
-    reqLoc = cs.getConstraintLocator(anchor, path, /*summaryFlags=*/0);
-  } else {
-    // Build simplified locator which only contains anchor and requirement info.
-    reqLoc = cs.getConstraintLocator(anchor, reqPath,
-                                     /*summaryFlags=*/0);
   }
 
+  auto *reqLoc = cs.getConstraintLocator(anchor, path,
+                                         /*summaryFlags=*/0);
+
   auto reqKind = static_cast<RequirementKind>(req.getValue2());
   switch (reqKind) {
   case RequirementKind::SameType: {
@@ -2789,32 +2782,20 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
 
     if (path.back().isTypeParameterRequirement() ||
         path.back().isConditionalRequirement()) {
-      ConstraintLocator *reqLoc = nullptr;
       if (path.back().isConditionalRequirement()) {
-        // Drop 'conditional requirement' element remainder
+        // Drop 'conditional requirement' element, remainder
         // of the path is going to point to type requirement
         // this conditional comes from.
         auto reqPath = ArrayRef<LocatorPathElt>(path).drop_back();
         // Underlying conformance requirement is itself fixed,
         // this wouldn't lead to a right solution.
-        if (hasFixFor(getConstraintLocator(anchor, reqPath.take_back(2),
+        if (hasFixFor(getConstraintLocator(anchor, reqPath,
                                            /*summaryFlags=*/0)))
           return SolutionKind::Error;
-
-        // For conditional requirements we need complete path, which includes
-        // type requirement position, to be able to fetch conformance later.
-        reqLoc = getConstraintLocator(locator);
-      } else {
-        // Let's strip all of the unnecessary information from locator,
-        // diagnostics only care about anchor - to lookup type,
-        // generic signature where requirement comes from, and
-        // what was the requirement# which is not satisfied.
-        auto reqPath = ArrayRef<LocatorPathElt>(path).take_back(2);
-        reqLoc = getConstraintLocator(anchor, reqPath,
-                                      /*summaryFlags=*/0);
       }
 
-      auto *fix = MissingConformance::create(*this, type, protocol, reqLoc);
+      auto *fix = MissingConformance::create(*this, type, protocol,
+                                             getConstraintLocator(locator));
       if (!recordFix(fix))
         return SolutionKind::Solved;
     }

trunk/stdlib/private/SwiftPrivateThreadExtras/SwiftPrivateThreadExtras.swift

@@ -89,14 +89,14 @@ public func _stdlib_thread_create_block<Argument, Result>(
   let contextAsVoidPointer = Unmanaged.passRetained(context).toOpaque()
 
 #if os(Windows)
-  var threadID =
+  let threadID =
       _beginthreadex(nil, 0, { invokeBlockContext($0)!
                                   .assumingMemoryBound(to: UInt32.self).pointee },
                      contextAsVoidPointer, 0, nil)
   if threadID == 0 {
     return (errno, nil)
   } else {
-    return (0, unsafeBitCast(threadID, to: ThreadHandle.self))
+    return (0, ThreadHandle(bitPattern: threadID))
   }
 #else
   var threadID = _make_pthread_t()

trunk/test/Interpreter/SDK/libc.swift

@@ -15,6 +15,13 @@
   import Glibc
 #elseif os(Windows)
   import MSVCRT
+
+  let S_IRUSR: Int32 = ucrt._S_IREAD
+  let S_IWUSR: Int32 = 0
+  let S_IXUSR: Int32 = 0
+
+  let S_IRGRP: Int32 = 0o0040
+  let S_IROTH: Int32 = 0o0004
 #else
 #error("Unsupported platform")
 #endif
@@ -49,7 +56,7 @@ if errFile != -1 {
 }
 
 // CHECK-NOT: error
-// CHECK: created mode *33216* *33216*
+// CHECK: created mode *{{33216|33060}}* *{{33216|33060}}*
 let tempFile = 
   open(tempPath, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IXUSR)
 if tempFile == -1 {
@@ -84,6 +91,10 @@ if err != 0 {
 
 print("created mode *\(statbuf1.st_mode)* *\(statbuf2.st_mode)*")
 
+#if os(Windows)
+assert(statbuf1.st_mode == S_IFREG | S_IRUSR | S_IRGRP | S_IROTH)
+#else
 assert(statbuf1.st_mode == S_IFREG | S_IRUSR | S_IWUSR | S_IXUSR)
+#endif
 assert(statbuf1.st_mode == statbuf2.st_mode)
 

trunk/test/SIL/unimplemented_initializer.swift

@@ -1,7 +1,5 @@
-// RUN: %target-swift-frontend -sdk %S/../SILGen/Inputs -I %S/../SILGen/Inputs -Xllvm -sil-print-debuginfo -enable-source-import -primary-file %s -emit-sil -emit-verbose-sil | %FileCheck %s -check-prefix=CHECK-DEBUG
-// RUN: %target-swift-frontend -sdk %S/../SILGen/Inputs -I %S/../SILGen/Inputs -Xllvm -sil-print-debuginfo -enable-source-import -primary-file %s -emit-sil -emit-verbose-sil -O | %FileCheck %s -check-prefix=CHECK-RELEASE
-
-// XFAIL: linux
+// RUN: %target-swift-frontend -sdk %S/../SILGen/Inputs -I %S/../SILGen/Inputs -Xllvm -sil-print-debuginfo -enable-objc-interop -enable-source-import -primary-file %s -emit-sil -emit-verbose-sil | %FileCheck %s -check-prefix=CHECK-DEBUG
+// RUN: %target-swift-frontend -sdk %S/../SILGen/Inputs -I %S/../SILGen/Inputs -Xllvm -sil-print-debuginfo -enable-objc-interop -enable-source-import -primary-file %s -emit-sil -emit-verbose-sil -O | %FileCheck %s -check-prefix=CHECK-RELEASE
 
 import gizmo