Merge branch 'master' into remotemirror-hide-reflection-sections

Author: mikeash

CHANGELOG.md

@@ -47,6 +47,25 @@ Swift 5.0
 Swift 4.1
 ---------
 
+* [SE-0075][]
+
+  Compile-time testing for the existence and importability of modules is now
+  implemented as a build configuration test.  The `canImport` test allows
+  the development of features that require a possibly-failing import 
+  declaration across multiple platforms.  
+
+  ```swift
+  #if canImport(UIKit)
+    import UIKit
+    class MyView : UIView {}
+  #elseif canImport(AppKit)
+    import AppKit
+    class MyView : NSView {}
+  #else
+    class MyView : CustomView {}
+  #endif
+  ```
+
 * [SE-0189][]
 
   If an initializer is declared in a different module from a struct, it must

cmake/modules/AddSwift.cmake

@@ -248,6 +248,13 @@ function(_add_variant_c_compile_flags)
     list(APPEND result "-D_DLL")
     # NOTE: We assume that we are using VS 2015 U2+
     list(APPEND result "-D_ENABLE_ATOMIC_ALIGNMENT_FIX")
+
+    # msvcprt's std::function requires RTTI, but we do not want RTTI data.
+    # Emulate /GR-
+    if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      list(APPEND result -frtti)
+      list(APPEND result -Xclang;-fno-rtti-data)
+    endif()
   endif()
 
   if(CFLAGS_ENABLE_ASSERTIONS)

cmake/modules/SwiftHandleGybSources.cmake

@@ -37,10 +37,6 @@ function(handle_gyb_source_single dependency_out_var_name)
       GYB_SINGLE # prefix
       "${options}" "${single_value_args}" "${multi_value_args}" ${ARGN})
 
-  set(gyb_flags
-      ${SWIFT_GYB_FLAGS}
-      ${GYB_SINGLE_FLAGS})
-
   set(gyb_tool "${SWIFT_SOURCE_DIR}/utils/gyb")
   set(gyb_tool_source "${gyb_tool}" "${gyb_tool}.py")
 
@@ -62,11 +58,9 @@ function(handle_gyb_source_single dependency_out_var_name)
       COMMAND
           "${CMAKE_COMMAND}" -E make_directory "${dir}"
       COMMAND
-          "${PYTHON_EXECUTABLE}" "${gyb_tool}" "${gyb_flags}"
-          -o "${GYB_SINGLE_OUTPUT}.tmp" "${GYB_SINGLE_SOURCE}"
+          "${PYTHON_EXECUTABLE}" "${gyb_tool}" ${SWIFT_GYB_FLAGS} ${GYB_SINGLE_FLAGS} -o "${GYB_SINGLE_OUTPUT}.tmp" "${GYB_SINGLE_SOURCE}"
       COMMAND
-          "${CMAKE_COMMAND}" -E copy_if_different
-          "${GYB_SINGLE_OUTPUT}.tmp" "${GYB_SINGLE_OUTPUT}"
+          "${CMAKE_COMMAND}" -E copy_if_different "${GYB_SINGLE_OUTPUT}.tmp" "${GYB_SINGLE_OUTPUT}"
       COMMAND
           "${CMAKE_COMMAND}" -E remove "${GYB_SINGLE_OUTPUT}.tmp"
       OUTPUT "${GYB_SINGLE_OUTPUT}"

include/swift/IDE/DigesterEnums.def

@@ -91,6 +91,7 @@ KEY(ownership)
 KEY(superclassUsr)
 KEY(parentExtensionReqs)
 KEY(hasDefaultArg)
+KEY(conformingProtocols)
 
 KNOWN_TYPE(Optional)
 KNOWN_TYPE(ImplicitlyUnwrappedOptional)

include/swift/IRGen/Linking.h

@@ -756,9 +756,6 @@ class LinkEntity {
   bool isForeignTypeMetadataCandidate() const {
     return getKind() == Kind::ForeignTypeMetadataCandidate;
   }
-  bool isObjCClassRef() const {
-    return getKind() == Kind::ObjCClassRef;
-  }
 
   /// Determine whether this entity will be weak-imported.
   bool isWeakImported(ModuleDecl *module) const {

include/swift/Syntax/CMakeLists.txt

@@ -1,6 +1,8 @@
-set(line_directive "#line" "%(line)d" "\"%(file)s\"")
-set(SWIFT_GYB_FLAGS
-  --line-directive "'${line_directive}'")
+if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+  set(SWIFT_GYB_FLAGS --line-directive "^\"#line %(line)d \\\"%(file)s\\\"^\"")
+else()
+  set(SWIFT_GYB_FLAGS --line-directive "\'#line" "%(line)d" "\"%(file)s\"\'")
+endif()
 
 set(generated_include_sources
     SyntaxKind.h.gyb

lib/IRGen/GenDecl.cpp

@@ -2442,15 +2442,6 @@ IRGenModule::getAddrOfLLVMVariableOrGOTEquivalent(LinkEntity entity,
                               Alignment alignment,
                               llvm::Type *defaultType,
                               ConstantReference::Directness forceIndirectness) {
-  // ObjC class references can always be directly referenced, even in
-  // the weird cases where we don't see a definition.
-  if (entity.isObjCClassRef()) {
-    auto value = getAddrOfObjCClassRef(
-      const_cast<ClassDecl *>(cast<ClassDecl>(entity.getDecl())));
-    return { cast<llvm::Constant>(value.getAddress()),
-             ConstantReference::Direct };
-  }
-
   // Ensure the variable is at least forward-declared.
   if (entity.isForeignTypeMetadataCandidate()) {
     auto foreignCandidate
@@ -2528,7 +2519,7 @@ IRGenModule::getTypeEntityReference(NominalTypeDecl *decl) {
 
     kind = TypeMetadataRecordKind::IndirectObjCClass;
     defaultTy = TypeMetadataPtrTy;
-    entity = LinkEntity::forObjCClassRef(clas);
+    entity = LinkEntity::forObjCClass(clas);
   } else {
     // A reference to a concrete type.
     // TODO: consider using a symbolic reference (i.e. a symbol string
@@ -2543,8 +2534,8 @@ IRGenModule::getTypeEntityReference(NominalTypeDecl *decl) {
 
   // Adjust the flags now that we know whether the reference to this
   // entity will be indirect.
-  if (ref.isIndirect()) {
-    assert(kind == TypeMetadataRecordKind::DirectNominalTypeDescriptor);
+  if (ref.isIndirect() &&
+      kind == TypeMetadataRecordKind::DirectNominalTypeDescriptor) {
     kind = TypeMetadataRecordKind::IndirectNominalTypeDescriptor;
   }
 

lib/SILGen/SILGenPoly.cpp

@@ -1573,6 +1573,9 @@ class ResultPlanner {
       ///
       /// Valid: reabstraction info, InnerResult, OuterResult.
       ReabstractDirectToDirect,
+
+      /// Ignore the next direct inner result, since the outer is 'Void'.
+      IgnoreDirectResult,
     };
 
     Operation(Kind kind) : TheKind(kind) {}
@@ -1717,6 +1720,24 @@ class ResultPlanner {
                                     SILResultInfo outerResult,
                                     SILValue optOuterResultAddr);
 
+  void planIgnoredResult(AbstractionPattern innerOrigType,
+                         CanType innerSubstType, PlanData &planData) {
+    if (innerOrigType.isTuple()) {
+      auto innerSubstTuple = cast<TupleType>(innerSubstType);
+      for (unsigned i = 0, n = innerSubstTuple->getNumElements(); i != n; ++i)
+        planIgnoredResult(innerOrigType.getTupleElementType(i),
+                          innerSubstTuple.getElementType(i), planData);
+      return;
+    }
+
+    auto innerResult = claimNextInnerResult(planData);
+    if (innerResult.isFormalIndirect() &&
+        SGF.silConv.isSILIndirect(innerResult))
+      (void)addInnerIndirectResultTemporary(planData, innerResult);
+    else
+      addIgnoreDirectResult();
+  }
+
   /// Claim the next inner result from the plan data.
   SILResultInfo claimNextInnerResult(PlanData &data) {
     return claimNext(data.InnerResults);
@@ -1866,6 +1887,10 @@ class ResultPlanner {
     op.OuterOrigType = outerOrigType;
     op.OuterSubstType = outerSubstType;
   }
+
+  void addIgnoreDirectResult() {
+    (void)addOperation(Operation::IgnoreDirectResult);
+  }
 };
 
 } // end anonymous namespace
@@ -1876,6 +1901,13 @@ void ResultPlanner::plan(AbstractionPattern innerOrigType,
                          AbstractionPattern outerOrigType,
                          CanType outerSubstType,
                          PlanData &planData) {
+  // Conversion from `() -> T` to `() -> Void` is allowed when
+  // the argument is a closure.
+  if (!innerSubstType->isVoid() && outerSubstType->isVoid()) {
+    planIgnoredResult(innerOrigType, innerSubstType, planData);
+    return;
+  }
+
   // The substituted types must match up in tuple-ness and arity.
   assert(
       isa<TupleType>(innerSubstType) == isa<TupleType>(outerSubstType) ||
@@ -2584,6 +2616,10 @@ void ResultPlanner::execute(ArrayRef<SILValue> innerDirectResults,
     case Operation::InjectOptionalIndirect:
       SGF.B.createInjectEnumAddr(Loc, op.OuterResultAddr, op.SomeDecl);
       continue;
+
+    case Operation::IgnoreDirectResult:
+      (void)claimNext(innerDirectResults);
+      continue;
     }
     llvm_unreachable("bad operation kind");
   }

lib/Sema/CSRanking.cpp

@@ -1007,14 +1007,32 @@ SolutionCompareResult ConstraintSystem::compareSolutions(
   // Compare the type variable bindings.
   auto &tc = cs.getTypeChecker();
   for (auto &binding : diff.typeBindings) {
+    auto type1 = binding.bindings[idx1];
+    auto type2 = binding.bindings[idx2];
+
+    auto &impl = binding.typeVar->getImpl();
+
+    if (auto *locator = impl.getLocator()) {
+      auto path = locator->getPath();
+      if (!path.empty() &&
+          path.back().getKind() == ConstraintLocator::ClosureResult) {
+        // Since we support `() -> T` to `() -> Void` and
+        // `() -> Never` to `() -> T` conversions, it's always
+        // preferable to pick `T` rather than `Never` with
+        // all else being equal.
+        if (type2->isUninhabited())
+          ++score1;
+
+        if (type1->isUninhabited())
+          ++score2;
+      }
+    }
+
     // If the type variable isn't one for which we should be looking at the
     // bindings, don't.
-    if (!binding.typeVar->getImpl().prefersSubtypeBinding())
+    if (!impl.prefersSubtypeBinding())
       continue;
 
-    auto type1 = binding.bindings[idx1];
-    auto type2 = binding.bindings[idx2];
-
     // If the types are equivalent, there's nothing more to do.
     if (type1->isEqual(type2))
       continue;

lib/Sema/CSSimplify.cpp

@@ -1212,10 +1212,8 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
     return result;
 
   // Result type can be covariant (or equal).
-  return matchTypes(func1->getResult(), func2->getResult(), subKind,
-                     subflags,
-                     locator.withPathElement(
-                       ConstraintLocator::FunctionResult));
+  return matchTypes(func1->getResult(), func2->getResult(), subKind, subflags,
+                    locator.withPathElement(ConstraintLocator::FunctionResult));
 }
 
 ConstraintSystem::TypeMatchResult
@@ -1501,6 +1499,8 @@ ConstraintSystem::TypeMatchResult
 ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
                              TypeMatchOptions flags,
                              ConstraintLocatorBuilder locator) {
+  auto origType1 = type1;
+
   bool isArgumentTupleConversion
           = kind == ConstraintKind::ArgumentTupleConversion ||
             kind == ConstraintKind::OperatorArgumentTupleConversion;
@@ -2243,7 +2243,32 @@ ConstraintSystem::matchTypes(Type type1, Type type2, ConstraintKind kind,
   // Allow '() -> T' to '() -> ()' and '() -> Never' to '() -> T' for closure
   // literals.
   if (auto elt = locator.last()) {
-    if (elt->getKind() == ConstraintLocator::ClosureResult) {
+    auto isClosureResult = [&]() {
+      if (elt->getKind() == ConstraintLocator::ClosureResult)
+        return true;
+
+      // If constraint is matching function results where
+      // left-hand side is a 'closure result' we need to allow
+      // certain implicit conversions.
+      if (elt->getKind() != ConstraintLocator::FunctionResult)
+        return false;
+
+      if (auto *typeVar = origType1->getAs<TypeVariableType>()) {
+        auto *locator = typeVar->getImpl().getLocator();
+        if (!locator)
+          return false;
+
+        auto path = locator->getPath();
+        if (path.empty())
+          return false;
+
+        return path.back().getKind() == ConstraintLocator::ClosureResult;
+      }
+
+      return false;
+    };
+
+    if (isClosureResult()) {
       if (concrete && kind >= ConstraintKind::Subtype &&
           (type1->isUninhabited() || type2->isVoid())) {
         increaseScore(SK_FunctionConversion);