---

yaml
---
r: 278397
b: refs/heads/swift-5.1-old-llvm-branch
c: 846ae44
h: refs/heads/master
i:
  278395: 155e951

Author: xedin

[refs]

@@ -1241,7 +1241,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-01-24-a: b6f62823aa5010b2ae53f15f72a57
 refs/heads/marcrasi-astverifier-disable: 3fac766a23a77ebd0640296bfd7fc116ea60a4e0
 refs/heads/revert-22227-a-tall-white-fountain-played: adfce60b2eaa54903ea189bed8a783bca609fa53
 refs/heads/revert-22300-revert-22227-a-tall-white-fountain-played: 5f92040224df7dd4e618fdfb367349df64d8acad
-refs/heads/swift-5.1-old-llvm-branch: e80c4d1959ebb9b1ec68ec7d23ce0a7e2f80b7c8
+refs/heads/swift-5.1-old-llvm-branch: 846ae44a1fc25509985b5b6a132bb3ccb13af9eb
 refs/heads/swift-5.1-branch: 8060872acb4105d9655e020fe047e1ebcd77d0fb
 refs/tags/swift-4.2.2-RELEASE: e429d1f1aaf59e69d38207a96e56265c7f6fccec
 refs/tags/swift-5.0-DEVELOPMENT-SNAPSHOT-2019-02-02-a: 3e5a03d32ff3b1e9af90d6c1198c14f938379a6e

branches/swift-5.1-old-llvm-branch/lib/Sema/CSSimplify.cpp

@@ -1228,6 +1228,10 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     llvm_unreachable("Not a relational constraint");
   }
 
+  // Input types can be contravariant (or equal).
+  auto argumentLocator =
+      locator.withPathElement(ConstraintLocator::FunctionArgument);
+
   TypeMatchOptions subflags = getDefaultDecompositionOptions(flags);
 
   SmallVector<AnyFunctionType::Param, 8> func1Params;
@@ -1254,8 +1258,23 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   auto implodeParams = [&](SmallVectorImpl<AnyFunctionType::Param> &params) {
     auto input = AnyFunctionType::composeInput(getASTContext(), params,
                                                /*canonicalVararg=*/false);
+
     params.clear();
-    params.emplace_back(input);
+    // If fixes are disabled let's do an easy thing and implode
+    // tuple directly into parameters list.
+    if (!shouldAttemptFixes()) {
+      params.emplace_back(input);
+      return;
+    }
+
+    // Synthesize new argument and bind it to tuple formed from existing
+    // arguments, this makes it easier to diagnose cases where we attempt
+    // a single tuple element formed when no arguments were present.
+    auto argLoc = argumentLocator.withPathElement(
+        LocatorPathElt::getSynthesizedArgument(0));
+    auto *typeVar = createTypeVariable(getConstraintLocator(argLoc));
+    params.emplace_back(typeVar);
+    assignFixedType(typeVar, input);
   };
 
   {
@@ -1323,10 +1342,6 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     }
   }
 
-  // Input types can be contravariant (or equal).
-  auto argumentLocator = locator.withPathElement(
-      ConstraintLocator::FunctionArgument);
-
   int diff = func1Params.size() - func2Params.size();
   if (diff != 0) {
     if (!shouldAttemptFixes())
@@ -1796,6 +1811,46 @@ repairFailures(ConstraintSystem &cs, Type lhs, Type rhs,
 
   auto &elt = path.back();
   switch (elt.getKind()) {
+  case ConstraintLocator::FunctionArgument: {
+    auto *argLoc = cs.getConstraintLocator(
+        locator.withPathElement(LocatorPathElt::getSynthesizedArgument(0)));
+
+    // Let's drop the last element which points to a single argument
+    // and see if this is a contextual mismatch.
+    path.pop_back();
+    if (path.empty() ||
+        !(path.back().getKind() == ConstraintLocator::ApplyArgToParam ||
+          path.back().getKind() == ConstraintLocator::ContextualType))
+      return;
+
+    auto arg = llvm::find_if(cs.getTypeVariables(),
+                             [&argLoc](const TypeVariableType *typeVar) {
+                               return typeVar->getImpl().getLocator() == argLoc;
+                             });
+
+    // What we have here is a form or tuple splat with no arguments
+    // demonstrated by following example:
+    //
+    // func foo<T: P>(_: T, _: (T.Element) -> Int) {}
+    // foo { 42 }
+    //
+    // In cases like this `T.Element` might be resolved to `Void`
+    // which means that we have to try a single empty tuple argument
+    // as a narrow exception to SE-0110, see `matchFunctionTypes`.
+    //
+    // But if `T.Element` didn't get resolved to `Void` we'd like
+    // to diagnose this as a missing argument which can't be ignored.
+    if (arg != cs.getTypeVariables().end()) {
+      auto fnType = FunctionType::get({FunctionType::Param(lhs)},
+                                      cs.getASTContext().TheEmptyTupleType);
+      conversionsOrFixes.push_back(AddMissingArguments::create(
+          cs, fnType, {FunctionType::Param(*arg)},
+          cs.getConstraintLocator(anchor, path,
+                                  /*summaryFlags=*/0)));
+    }
+    break;
+  }
+
   case ConstraintLocator::TypeParameterRequirement:
   case ConstraintLocator::ConditionalRequirement: {
     if (auto *fix = fixRequirementFailure(cs, lhs, rhs, anchor, path))
@@ -5707,7 +5762,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
 
   case FixKind::SkipSameTypeRequirement:
   case FixKind::SkipSuperclassRequirement:
-  case FixKind::ContextualMismatch: {
+  case FixKind::ContextualMismatch:
+  case FixKind::AddMissingArguments: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }
 
@@ -5723,7 +5779,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowTypeOrInstanceMember:
   case FixKind::AllowInvalidPartialApplication:
   case FixKind::AllowInvalidInitRef:
-  case FixKind::AddMissingArguments:
     llvm_unreachable("handled elsewhere");
   }
 

branches/swift-5.1-old-llvm-branch/stdlib/public/Darwin/os/os.m

@@ -87,8 +87,8 @@
   if (_os_log_encode(buf, fmt, args, saved_errno, &ob)) {
     if (os_log_pack_send) {
       size_t sz = _os_log_pack_size(ob.ob_len);
-      uint8_t _Alignas(os_log_pack_s) pack[sz];
-      os_log_pack_t p = (os_log_pack_t)pack;
+      uint8_t _Alignas(os_log_pack_s) buf[sz];
+      os_log_pack_t p = (os_log_pack_t)buf;
       /*
        * _os_log_encode has already packed `saved_errno` into a
        * OSLF_CMD_TYPE_SCALAR command as the OSLF_CMD_TYPE_ERRNO does not
@@ -136,8 +136,8 @@
       _os_log_encode(buf, fmt, args, saved_errno, &ob);
   if (encoded) {
     size_t sz = _os_log_pack_size(ob.ob_len);
-    uint8_t _Alignas(os_log_pack_s) pack[sz];
-    os_log_pack_t p = (os_log_pack_t)pack;
+    uint8_t _Alignas(os_log_pack_s) buf[sz];
+    os_log_pack_t p = (os_log_pack_t)buf;
     uint8_t *ptr = _os_signpost_pack_fill(p, sz, saved_errno, dso,
         fmt, spnm, spid);
     p->olp_pc = ra;

branches/swift-5.1-old-llvm-branch/stdlib/public/SwiftShims/GlobalObjects.h

@@ -102,6 +102,13 @@ static_assert(
     4 * sizeof(__swift_intptr_t) + sizeof(__swift_int64_t),
   "_SwiftSetBodyStorage has unexpected size");
 
+static_assert(std::is_pod<_SwiftEmptyArrayStorage>::value,
+              "empty array type should be POD");
+static_assert(std::is_pod<_SwiftEmptyDictionarySingleton>::value,
+              "empty dictionary type should be POD");
+static_assert(std::is_pod<_SwiftEmptySetSingleton>::value,
+              "empty set type should be POD");
+
 }} // extern "C", namespace swift
 #endif
 

branches/swift-5.1-old-llvm-branch/stdlib/public/SwiftShims/HeapObject.h

@@ -93,6 +93,8 @@ __swift_size_t swift_weakRetainCount(HeapObject *obj);
 #endif
 
 #ifdef __cplusplus
+static_assert(swift::IsTriviallyConstructible<HeapObject>::value,
+              "HeapObject must be trivially initializable");
 static_assert(std::is_trivially_destructible<HeapObject>::value,
               "HeapObject must be trivially destructible");
 

branches/swift-5.1-old-llvm-branch/stdlib/public/SwiftShims/RefCount.h

@@ -1188,6 +1188,8 @@ class RefCounts {
 typedef RefCounts<InlineRefCountBits> InlineRefCounts;
 typedef RefCounts<SideTableRefCountBits> SideTableRefCounts;
 
+static_assert(swift::IsTriviallyConstructible<InlineRefCounts>::value,
+              "InlineRefCounts must be trivially initializable");
 static_assert(std::is_trivially_destructible<InlineRefCounts>::value,
               "InlineRefCounts must be trivially destructible");
 

branches/swift-5.1-old-llvm-branch/stdlib/public/core/Optional.swift

@@ -300,9 +300,7 @@ func _diagnoseUnexpectedNilOptional(_filenameStart: Builtin.RawPointer,
                                     _filenameIsASCII: Builtin.Int1,
                                     _line: Builtin.Word,
                                     _isImplicitUnwrap: Builtin.Int1) {
-  // Cannot use _preconditionFailure as the file and line info would not be
-  // printed.
-  preconditionFailure(
+  _preconditionFailure(
     Bool(_isImplicitUnwrap)
       ? "Unexpectedly found nil while implicitly unwrapping an Optional value"
       : "Unexpectedly found nil while unwrapping an Optional value",

branches/swift-5.1-old-llvm-branch/stdlib/public/runtime/HeapObject.cpp

@@ -84,11 +84,9 @@ static HeapObject *_swift_allocObject_(HeapMetadata const *metadata,
   assert(isAlignmentMask(requiredAlignmentMask));
   auto object = reinterpret_cast<HeapObject *>(
       swift_slowAlloc(requiredSize, requiredAlignmentMask));
-
-  // NOTE: this relies on the C++17 guaranteed semantics of no null-pointer
-  // check on the placement new allocator which we have observed on Windows,
-  // Linux, and macOS.
-  new (object) HeapObject(metadata);
+  // FIXME: this should be a placement new but that adds a null check
+  object->metadata = metadata;
+  object->refCounts.init();
 
   // If leak tracking is enabled, start tracking this object.
   SWIFT_LEAKS_START_TRACKING_OBJECT(object);

branches/swift-5.1-old-llvm-branch/test/Constraints/closures.swift

@@ -894,12 +894,8 @@ do {
   }
 
   func foo(_ arr: [Int]) {
-    // FIXME: This behavior related to tuple splat being allowed
-    //        in conversion between a single dependent member
-    //        parameter and empty parameter functions e.g.
-    //        () -> Void `convertable to` (T.V) -> Void.
     _ = S(arr, id: \.self_) {
-      // expected-error@-1 {{type '_' has no member 'self_'}}
+      // expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{30-30=_ in }}
       return 42
     }
   }

branches/swift-5.1-old-llvm-branch/test/IDE/complete_override.swift

@@ -110,7 +110,6 @@
 // RUN: %target-swift-ide-test -enable-objc-interop -code-completion -source-filename %s -code-completion-token=OMIT_KEYWORD9_LET -code-completion-keywords=false | %FileCheck %s -check-prefix=OMIT_KEYWORD4
 // RUN: %target-swift-ide-test -enable-objc-interop -code-completion -source-filename %s -code-completion-token=OMIT_KEYWORD10 -code-completion-keywords=false | %FileCheck %s -check-prefix=WITH_PA_NO_PROTOFUNCA
 
-// RUN: %target-swift-ide-test -enable-objc-interop -code-completion -source-filename %s -code-completion-token=SR2560_WHERE_CLAUSE -code-completion-keywords=false | %FileCheck %s -check-prefix=SR2560_WHERE_CLAUSE
 // RUN: %target-swift-ide-test -enable-objc-interop -code-completion -source-filename %s -code-completion-token=HAS_THROWING -code-completion-keywords=false | %FileCheck %s -check-prefix=HAS_THROWING
 // RUN: %target-swift-ide-test -enable-objc-interop -code-completion -source-filename %s -code-completion-token=ASSOC_TYPE1 -code-completion-keywords=false | %FileCheck %s -check-prefix=ASSOC_TYPE1
 
@@ -524,17 +523,6 @@ class OmitKW10: ProtocolA {
 // WITH_PA
 }
 
-protocol SR2560Proto {
-  func foo<S : Sequence>(x: S) where S.Iterator.Element == Int
-}
-class SR2560Class: SR2560Proto {
-  #^SR2560_WHERE_CLAUSE^#
-}
-
-// SR2560_WHERE_CLAUSE: Begin completions
-// SR2560_WHERE_CLAUSE: Decl[InstanceMethod]/Super: func foo<S>(x: S) where S : Sequence, S.Element == Int {|};
-// SR2560_WHERE_CLAUSE: End completions
-
 protocol HasThrowingProtocol {
   func foo() throws
 }

branches/swift-5.1-old-llvm-branch/test/stdlib/OptionalTraps.swift

@@ -25,22 +25,7 @@ OptionalTraps.test("UnwrapNone")
     { _isFastAssertConfiguration() },
     reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .code {
-  let a: AnyObject? = returnNil()
-  expectCrashLater()
-  let unwrapped: AnyObject = a!
-  _blackHole(unwrapped)
-}
-
-OptionalTraps.test("UnwrapNone/location")
-  .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
-  .crashOutputMatches(_isDebugAssertConfiguration()
-                        ? "test/stdlib/OptionalTraps.swift, line 45"
-                        : "")
-  .code {
-  expectCrashLater()
-  let a: AnyObject? = returnNil()
+  var a: AnyObject? = returnNil()
   expectCrashLater()
   let unwrapped: AnyObject = a!
   _blackHole(unwrapped)

branches/swift-5.1-old-llvm-branch/unittests/runtime/CMakeLists.txt

@@ -1,15 +1,13 @@
 if(("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SDK}") AND
    ("${SWIFT_HOST_VARIANT_ARCH}" STREQUAL "${SWIFT_PRIMARY_VARIANT_ARCH}"))
 
-  if("${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
-    # Do nothing
-  elseif(SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER)
+  if(SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER)
     if(NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
       message(FATAL_ERROR "Building the swift runtime is not supported with ${CMAKE_C_COMPILER_ID}. Use the just-built clang instead.")
+    else()
+      message(WARNING "Building the swift runtime using the host compiler, and not the just-built clang.")
     endif()
   else()
-    message(WARNING "Building the swift runtime using the host compiler, and not the just-built clang.")
-
     # If we use Clang-cl or MSVC, CMake provides default compiler and linker flags that are incompatible
     # with the frontend of Clang or Clang++.
     if(SWIFT_COMPILER_IS_MSVC_LIKE)

branches/swift-5.1-old-llvm-branch/validation-test/stdlib/Collection/FlattenCollection.swift.gyb

@@ -2,10 +2,6 @@
 // RUN: %target-run-simple-swiftgyb
 // REQUIRES: executable_test
 
-// FIXME: the test is too slow when the standard library is not optimized.
-// rdar://problem/46878013
-// REQUIRES: optimized_stdlib
-
 import SwiftPrivate
 import StdlibUnittest
 import StdlibCollectionUnittest

branches/swift-5.1-old-llvm-branch/validation-test/stdlib/Collection/LazyFilterCollection.swift.gyb

@@ -2,10 +2,6 @@
 // RUN: %target-run-simple-swiftgyb
 // REQUIRES: executable_test
 
-// FIXME: the test is too slow when the standard library is not optimized.
-// rdar://problem/46878013
-// REQUIRES: optimized_stdlib
-
 import SwiftPrivate
 import StdlibUnittest
 import StdlibCollectionUnittest