---

yaml
---
r: 345078
b: refs/heads/master
c: f49b28c
h: refs/heads/master

Author: swift-ci

[refs]

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

trunk/benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -315,6 +315,7 @@ function (swift_benchmark_compile_archopts)
   if (is_darwin)
     list(APPEND common_options
       "-I" "${srcdir}/utils/ObjectiveCTests"
+      "-I" "${srcdir}/utils/LibProc"
       "-F" "${sdk}/../../../Developer/Library/Frameworks"
       "-sdk" "${sdk}"
       "-no-link-objc-runtime")
@@ -344,6 +345,7 @@ function (swift_benchmark_compile_archopts)
     list(APPEND common_options_driver
       "-sdk" "${sdk}"
       "-F" "${sdk}/../../../Developer/Library/Frameworks"
+      "-I" "${srcdir}/utils/LibProc"
       "-no-link-objc-runtime")
   endif()
   set(bench_library_objects)

trunk/benchmark/utils/DriverUtils.swift

@@ -14,6 +14,7 @@
 import Glibc
 #else
 import Darwin
+import LibProc
 #endif
 
 import TestsUtils
@@ -297,6 +298,27 @@ final class SampleRunner {
     (start, end, lastYield) = (now, now, now)
   }
 
+#if os(Linux)
+  private static func getExecutedInstructions() -> UInt64 {
+    // FIXME: there is a Linux PMC API you can use to get this, but it's
+    // not quite so straightforward.
+    return 0
+  }
+#else
+  private static func getExecutedInstructions() -> UInt64 {
+    if #available(OSX 10.9, iOS 7.0, *) {
+      var u = rusage_info_v4()
+      let p = UnsafeMutablePointer(&u)
+      p.withMemoryRebound(to: Optional<rusage_info_t>.self, capacity: 1) { up in
+        let _ = proc_pid_rusage(getpid(), RUSAGE_INFO_V4, up)
+      }
+      return u.ri_instructions
+    } else {
+      return 0
+    }
+  }
+#endif
+
   private static func getResourceUtilization() -> rusage {
     var u = rusage(); getrusage(RUSAGE_SELF, &u); return u
   }

trunk/benchmark/utils/LibProc/LibProcIncludeSystemHeader.h

@@ -0,0 +1,22 @@
+//===--- LibProcIncludeSystemHeader.h -------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This file exists to include the not-yet-modularized libproc.h system header.
+
+#if __has_include(<libproc.h>)
+#include <libproc.h>
+#else
+#include <Availability.h>
+#include <sys/resource.h>
+// Some SDKs are missing the libproc.h header, despite this symbol being present.
+int proc_pid_rusage(int pid, int flavor, rusage_info_t *buffer) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0);
+#endif

trunk/benchmark/utils/LibProc/module.modulemap

@@ -0,0 +1,16 @@
+//===--- module.modulemap -------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+module LibProc {
+  header "LibProcIncludeSystemHeader.h"
+  export *
+}

trunk/lib/Sema/CSBindings.cpp

@@ -209,9 +209,45 @@ void ConstraintSystem::PotentialBindings::addPotentialBinding(
   if (auto *literalProtocol = binding.DefaultedProtocol)
     foundLiteralBinding(literalProtocol);
 
+  // If the type variable can't bind to an lvalue, make sure the
+  // type we pick isn't an lvalue.
+  if (!TypeVar->getImpl().canBindToLValue() &&
+      binding.BindingType->hasLValueType()) {
+    binding = binding.withType(binding.BindingType->getRValueType());
+  }
+
+  if (!isViable(binding))
+    return;
+
   Bindings.push_back(std::move(binding));
 }
 
+bool ConstraintSystem::PotentialBindings::isViable(
+    PotentialBinding &binding) const {
+  // Prevent against checking against the same bound generic type
+  // over and over again. Doing so means redundant work in the best
+  // case. In the worst case, we'll produce lots of duplicate solutions
+  // for this constraint system, which is problematic for overload
+  // resolution.
+  auto type = binding.BindingType;
+  if (type->hasTypeVariable()) {
+    auto *BGT = type->getAs<BoundGenericType>();
+    if (!BGT)
+      return true;
+
+    for (auto &existing : Bindings) {
+      auto existingBGT = existing.BindingType->getAs<BoundGenericType>();
+      if (!existingBGT)
+        continue;
+
+      if (BGT != existingBGT && BGT->getDecl() == existingBGT->getDecl())
+        return false;
+    }
+  }
+
+  return true;
+}
+
 Optional<ConstraintSystem::PotentialBinding>
 ConstraintSystem::getPotentialBindingForRelationalConstraint(
     PotentialBindings &result, Constraint *constraint,

trunk/lib/Sema/CSSolver.cpp

@@ -580,42 +580,10 @@ bool ConstraintSystem::tryTypeVariableBindings(
         continue;
 
       auto type = binding.BindingType;
-
-      // If the type variable can't bind to an lvalue, make sure the
-      // type we pick isn't an lvalue.
-      if (!typeVar->getImpl().canBindToLValue())
-        type = type->getRValueType();
-
-      // Remove parentheses. They're insignificant here.
-      type = type->getWithoutParens();
-
       // If we've already tried this binding, move on.
       if (!boundTypes.insert(type.getPointer()).second)
         continue;
 
-      // Prevent against checking against the same bound generic type
-      // over and over again. Doing so means redundant work in the best
-      // case. In the worst case, we'll produce lots of duplicate solutions
-      // for this constraint system, which is problematic for overload
-      // resolution.
-      if (type->hasTypeVariable()) {
-        auto triedBinding = false;
-        if (auto BGT = type->getAs<BoundGenericType>()) {
-          for (auto bt : boundTypes) {
-            if (auto BBGT = bt->getAs<BoundGenericType>()) {
-              if (BGT != BBGT &&
-                  BGT->getDecl() == BBGT->getDecl()) {
-                triedBinding = true;
-                break;
-              }
-            }
-          }
-        }
-
-        if (triedBinding)
-          continue;
-      }
-
       if (tc.getLangOpts().DebugConstraintSolver) {
         auto &log = getASTContext().TypeCheckerDebug->getStream();
         log.indent(depth * 2)
@@ -679,8 +647,7 @@ bool ConstraintSystem::tryTypeVariableBindings(
     // Enumerate the supertypes of each of the types we tried.
     for (auto binding : bindings) {
       const auto type = binding.BindingType;
-      if (type->hasError())
-        continue;
+      assert(!type->hasError());
 
       // After our first pass, note that we've explored these
       // types.

trunk/lib/Sema/ConstraintSystem.h

@@ -2774,11 +2774,15 @@ class ConstraintSystem {
                      ConstraintKind bindingSource,
                      ProtocolDecl *defaultedProtocol = nullptr,
                      ConstraintLocator *defaultableBinding = nullptr)
-        : BindingType(type), Kind(kind), BindingSource(bindingSource),
-          DefaultedProtocol(defaultedProtocol),
+        : BindingType(type->getWithoutParens()), Kind(kind),
+          BindingSource(bindingSource), DefaultedProtocol(defaultedProtocol),
           DefaultableBinding(defaultableBinding) {}
 
     bool isDefaultableBinding() const { return DefaultableBinding != nullptr; }
+
+    PotentialBinding withType(Type type) const {
+      return {type, Kind, BindingSource, DefaultedProtocol, DefaultableBinding};
+    }
   };
 
   struct PotentialBindings {
@@ -2869,6 +2873,9 @@ class ConstraintSystem {
     void addPotentialBinding(PotentialBinding binding,
                              bool allowJoinMeet = true);
 
+    /// Check if this binding is viable for inclusion in the set.
+    bool isViable(PotentialBinding &binding) const;
+
     void dump(llvm::raw_ostream &out,
               unsigned indent = 0) const LLVM_ATTRIBUTE_USED {
       out.indent(indent);

trunk/validation-test/Sema/type_checker_perf/slow/rdar19181998.swift.gyb renamed to trunk/validation-test/Sema/type_checker_perf/fast/rdar19181998.swift.gyb

@@ -1,4 +1,4 @@
-// RUN: %scale-test --invert-result --begin 1 --end 4 --step 1 --select incrementScopeCounter %s
+// RUN: %scale-test --begin 1 --end 30 --step 1 --select incrementScopeCounter %s
 // REQUIRES: OS=macosx
 // REQUIRES: asserts