Merge remote-tracking branch 'origin/master' into master-next

Author: swift-ci

cmake/modules/StandaloneOverlay.cmake

@@ -21,12 +21,13 @@ set(SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS "9.0" CACHE STRING "")
 set(SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS "2.0" CACHE STRING "")
 set(SWIFT_ENABLE_PARSEABLE_MODULE_INTERFACES TRUE)
 
-set(SWIFT_SOURCE_DIR "${SWIFT_SOURCE_ROOT}/src/swift" CACHE PATH "")
+set(SWIFT_SOURCE_DIR "${SWIFT_SOURCE_ROOT}/swift" CACHE PATH "")
 set(SWIFT_NATIVE_SWIFT_TOOLS_PATH "${TOOLCHAIN_DIR}/usr/bin" CACHE PATH "")
 set(SWIFT_SDKS ${SWIFT_HOST_VARIANT_SDK})
 
-find_package(LLVM CONFIG REQUIRED NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
-list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_DIR}" "${PROJECT_SOURCE_DIR}/../../../../cmake/modules")
+list(APPEND CMAKE_MODULE_PATH
+  "${SWIFT_SOURCE_ROOT}/llvm/cmake/modules"
+  "${PROJECT_SOURCE_DIR}/../../../../cmake/modules")
 
 set(SWIFT_DARWIN_XCRUN_TOOLCHAIN "XcodeDefault" CACHE STRING
     "The name of the toolchain to pass to 'xcrun'")

include/swift/Frontend/PrintingDiagnosticConsumer.h

@@ -22,6 +22,7 @@
 #include "swift/AST/DiagnosticConsumer.h"
 
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Process.h"
 
 namespace swift {
 
@@ -42,6 +43,7 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
 
   void forceColors() {
     ForceColors = true;
+    llvm::sys::Process::UseANSIEscapeCodes(true);
   }
 
   bool didErrorOccur() {

lib/ClangImporter/ClangImporter.cpp

@@ -716,6 +716,8 @@ addCommonInvocationArguments(std::vector<std::string> &invocationArgStrs,
     invocationArgStrs.push_back(importerOpts.IndexStorePath);
   }
 
+  invocationArgStrs.push_back("-fansi-escape-codes");
+
   for (auto extraArg : importerOpts.ExtraArgs) {
     invocationArgStrs.push_back(extraArg);
   }
@@ -876,7 +878,6 @@ ClangImporter::create(ASTContext &ctx,
   // Clang expects this to be like an actual command line. So we need to pass in
   // "clang" for argv[0]
   invocationArgStrs.push_back("clang");
-
   switch (importerOpts.Mode) {
   case ClangImporterOptions::Modes::Normal:
     getNormalInvocationArguments(invocationArgStrs, ctx, importerOpts);

lib/Sema/CSDiagnostics.cpp

@@ -549,16 +549,67 @@ bool MemberAccessOnOptionalBaseFailure::diagnoseAsError() {
                                            resultIsOptional, SourceRange());
 }
 
-// Suggest a default value via ?? <default value>
-static void offerDefaultValueUnwrapFixit(TypeChecker &TC, DeclContext *DC, Expr *expr, Expr *rootExpr) {
-  auto diag =
-  TC.diagnose(expr->getLoc(), diag::unwrap_with_default_value);
+Optional<AnyFunctionType::Param>
+MissingOptionalUnwrapFailure::getOperatorParameterFor(Expr *expr) const {
+  auto *parentExpr = findParentExpr(expr);
+  if (!parentExpr)
+    return None;
+
+  auto getArgIdx = [](TupleExpr *tuple, Expr *argExpr) -> unsigned {
+    for (unsigned i = 0, n = tuple->getNumElements(); i != n; ++i) {
+      if (tuple->getElement(i) == argExpr)
+        return i;
+    }
+    llvm_unreachable("argument is not in enclosing tuple?!");
+  };
+
+  auto *tupleExpr = dyn_cast<TupleExpr>(parentExpr);
+  if (!(tupleExpr && tupleExpr->isImplicit()))
+    return None;
+
+  parentExpr = findParentExpr(tupleExpr);
+  if (!(parentExpr && isa<ApplyExpr>(parentExpr)))
+    return None;
+
+  auto &cs = getConstraintSystem();
+  auto *fnExpr = cast<ApplyExpr>(parentExpr)->getFn();
+  if (auto overload =
+          getOverloadChoiceIfAvailable(cs.getConstraintLocator(fnExpr))) {
+    if (auto *decl = overload->choice.getDecl()) {
+      if (!decl->isOperator())
+        return None;
+
+      auto *fnType = overload->openedType->castTo<FunctionType>();
+      return fnType->getParams()[getArgIdx(tupleExpr, expr)];
+    }
+  }
+
+  return None;
+}
+
+void MissingOptionalUnwrapFailure::offerDefaultValueUnwrapFixIt(
+    DeclContext *DC, Expr *expr) const {
+  auto *anchor = getAnchor();
+
+  // If anchor is an explicit address-of, or expression which produces
+  // an l-value (e.g. first argument of `+=` operator), let's not
+  // suggest default value here because that would produce r-value type.
+  if (isa<InOutExpr>(anchor))
+    return;
 
+  if (auto param = getOperatorParameterFor(anchor)) {
+    if (param->isInOut())
+      return;
+  }
+
+  auto diag = emitDiagnostic(expr->getLoc(), diag::unwrap_with_default_value);
+
+  auto &TC = getTypeChecker();
   // Figure out what we need to parenthesize.
   bool needsParensInside =
-  exprNeedsParensBeforeAddingNilCoalescing(TC, DC, expr);
+      exprNeedsParensBeforeAddingNilCoalescing(TC, DC, expr);
   bool needsParensOutside =
-  exprNeedsParensAfterAddingNilCoalescing(TC, DC, expr, rootExpr);
+      exprNeedsParensAfterAddingNilCoalescing(TC, DC, expr, getParentExpr());
 
   llvm::SmallString<2> insertBefore;
   llvm::SmallString<32> insertAfter;
@@ -580,8 +631,8 @@ static void offerDefaultValueUnwrapFixit(TypeChecker &TC, DeclContext *DC, Expr
 }
 
 // Suggest a force-unwrap.
-static void offerForceUnwrapFixit(ConstraintSystem &CS, Expr *expr) {
-  auto diag = CS.TC.diagnose(expr->getLoc(), diag::unwrap_with_force_value);
+void MissingOptionalUnwrapFailure::offerForceUnwrapFixIt(Expr *expr) const {
+  auto diag = emitDiagnostic(expr->getLoc(), diag::unwrap_with_force_value);
 
   // If expr is optional as the result of an optional chain and this last
   // dot isn't a member returning optional, then offer to force the last
@@ -590,7 +641,7 @@ static void offerForceUnwrapFixit(ConstraintSystem &CS, Expr *expr) {
     if (auto dotExpr =
         dyn_cast<UnresolvedDotExpr>(optionalChain->getSubExpr())) {
       auto bind = dyn_cast<BindOptionalExpr>(dotExpr->getBase());
-      if (bind && !CS.getType(dotExpr)->getOptionalObjectType()) {
+      if (bind && !getType(dotExpr)->getOptionalObjectType()) {
         diag.fixItReplace(SourceRange(bind->getLoc()), "!");
         return;
       }
@@ -601,7 +652,7 @@ static void offerForceUnwrapFixit(ConstraintSystem &CS, Expr *expr) {
     diag.fixItInsertAfter(expr->getEndLoc(), "!");
   } else {
     diag.fixItInsert(expr->getStartLoc(), "(")
-    .fixItInsertAfter(expr->getEndLoc(), ")!");
+        .fixItInsertAfter(expr->getEndLoc(), ")!");
   }
 }
 
@@ -622,8 +673,38 @@ class VarDeclMultipleReferencesChecker : public ASTWalker {
   int referencesCount() { return count; }
 };
 
-static bool diagnoseUnwrap(ConstraintSystem &CS, Expr *expr, Expr *rootExpr, Type baseType,
-                           Type unwrappedType) {
+bool MissingOptionalUnwrapFailure::diagnoseAsError() {
+  if (hasComplexLocator())
+    return false;
+
+  auto *anchor = getAnchor();
+
+  if (auto assignExpr = dyn_cast<AssignExpr>(anchor))
+    anchor = assignExpr->getSrc();
+
+  auto *unwrappedExpr = anchor->getValueProvidingExpr();
+
+  if (auto *tryExpr = dyn_cast<OptionalTryExpr>(unwrappedExpr)) {
+    bool isSwift5OrGreater = getASTContext().isSwiftVersionAtLeast(5);
+    auto subExprType = getType(tryExpr->getSubExpr());
+    bool subExpressionIsOptional = (bool)subExprType->getOptionalObjectType();
+
+    if (isSwift5OrGreater && subExpressionIsOptional) {
+      // Using 'try!' won't change the type for a 'try?' with an optional
+      // sub-expr under Swift 5+, so just report that a missing unwrap can't be
+      // handled here.
+      return false;
+    }
+
+    emitDiagnostic(tryExpr->getTryLoc(), diag::missing_unwrap_optional_try,
+                   getType(anchor)->getRValueType())
+        .fixItReplace({tryExpr->getTryLoc(), tryExpr->getQuestionLoc()},
+                      "try!");
+    return true;
+  }
+
+  auto baseType = getBaseType();
+  auto unwrappedType = getUnwrappedType();
 
   assert(!baseType->hasTypeVariable() &&
          "Base type must not be a type variable");
@@ -633,15 +714,14 @@ static bool diagnoseUnwrap(ConstraintSystem &CS, Expr *expr, Expr *rootExpr, Typ
   if (!baseType->getOptionalObjectType())
     return false;
 
-  CS.TC.diagnose(expr->getLoc(), diag::optional_not_unwrapped, baseType,
-                 unwrappedType);
+  emitDiagnostic(unwrappedExpr->getLoc(), diag::optional_not_unwrapped,
+                 baseType, unwrappedType);
 
   // If the expression we're unwrapping is the only reference to a
   // local variable whose type isn't explicit in the source, then
   // offer unwrapping fixits on the initializer as well.
-  if (auto declRef = dyn_cast<DeclRefExpr>(expr)) {
+  if (auto declRef = dyn_cast<DeclRefExpr>(unwrappedExpr)) {
     if (auto varDecl = dyn_cast<VarDecl>(declRef->getDecl())) {
-
       bool singleUse = false;
       AbstractFunctionDecl *AFD = nullptr;
       if (auto contextDecl = varDecl->getDeclContext()->getAsDecl()) {
@@ -658,69 +738,37 @@ static bool diagnoseUnwrap(ConstraintSystem &CS, Expr *expr, Expr *rootExpr, Typ
 
         Expr *initializer = varDecl->getParentInitializer();
         if (auto declRefExpr = dyn_cast<DeclRefExpr>(initializer)) {
-          if (declRefExpr->getDecl()->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>()) {
-            CS.TC.diagnose(declRefExpr->getLoc(), diag::unwrap_iuo_initializer,
+          if (declRefExpr->getDecl()
+                  ->getAttrs()
+                  .hasAttribute<ImplicitlyUnwrappedOptionalAttr>()) {
+            emitDiagnostic(declRefExpr->getLoc(), diag::unwrap_iuo_initializer,
                            baseType);
           }
         }
 
         auto fnTy = AFD->getInterfaceType()->castTo<AnyFunctionType>();
-        bool voidReturn = fnTy->getResult()->isEqual(TupleType::getEmpty(CS.DC->getASTContext()));
+        bool voidReturn =
+            fnTy->getResult()->isEqual(TupleType::getEmpty(getASTContext()));
 
-        auto diag = CS.TC.diagnose(varDecl->getLoc(), diag::unwrap_with_guard);
+        auto diag = emitDiagnostic(varDecl->getLoc(), diag::unwrap_with_guard);
         diag.fixItInsert(binding->getStartLoc(), "guard ");
         if (voidReturn) {
           diag.fixItInsertAfter(binding->getEndLoc(), " else { return }");
         } else {
           diag.fixItInsertAfter(binding->getEndLoc(), " else { return <"
-                                "#default value#" "> }");
+                                                      "#default value#"
+                                                      "> }");
         }
         diag.flush();
 
-        offerDefaultValueUnwrapFixit(CS.TC, varDecl->getDeclContext(), 
-                                     initializer, rootExpr);
-        offerForceUnwrapFixit(CS, initializer);
+        offerDefaultValueUnwrapFixIt(varDecl->getDeclContext(), initializer);
+        offerForceUnwrapFixIt(initializer);
       }
     }
   }
 
-  offerDefaultValueUnwrapFixit(CS.TC, CS.DC, expr, rootExpr);
-  offerForceUnwrapFixit(CS, expr);
-  return true;
-}
-
-bool MissingOptionalUnwrapFailure::diagnoseAsError() {
-  if (hasComplexLocator())
-    return false;
-
-  auto *anchor = getAnchor();
-  auto *rootExpr = getParentExpr();
-
-  if (auto assignExpr = dyn_cast<AssignExpr>(anchor))
-    anchor = assignExpr->getSrc();
-  
-  auto *unwrapped = anchor->getValueProvidingExpr();
-  auto type = getType(anchor)->getRValueType();
-
-  auto *tryExpr = dyn_cast<OptionalTryExpr>(unwrapped);
-  if (!tryExpr) {
-    return diagnoseUnwrap(getConstraintSystem(), unwrapped, rootExpr, getBaseType(),
-                          getUnwrappedType());
-  }
-
-  bool isSwift5OrGreater = getTypeChecker().getLangOpts().isSwiftVersionAtLeast(5);
-  auto subExprType = getType(tryExpr->getSubExpr());
-  bool subExpressionIsOptional = (bool)subExprType->getOptionalObjectType();
-  
-  
-  if (isSwift5OrGreater && subExpressionIsOptional) {
-    // Using 'try!' won't change the type for a 'try?' with an optional sub-expr
-    // under Swift 5+, so just report that a missing unwrap can't be handled here.
-    return false;
-  }
-
-  emitDiagnostic(tryExpr->getTryLoc(), diag::missing_unwrap_optional_try, type)
-      .fixItReplace({tryExpr->getTryLoc(), tryExpr->getQuestionLoc()}, "try!");
+  offerDefaultValueUnwrapFixIt(getDC(), unwrappedExpr);
+  offerForceUnwrapFixIt(unwrappedExpr);
   return true;
 }
 

lib/Sema/CSDiagnostics.h

@@ -565,6 +565,15 @@ class MissingOptionalUnwrapFailure final : public FailureDiagnostic {
   Type getUnwrappedType() const {
     return resolveType(UnwrappedType, /*reconstituteSugar=*/true);
   }
+
+  /// Suggest a default value via `?? <default value>`
+  void offerDefaultValueUnwrapFixIt(DeclContext *DC, Expr *expr) const;
+  /// Suggest a force optional unwrap via `!`
+  void offerForceUnwrapFixIt(Expr *expr) const;
+
+  /// Determine whether given expression is an argument used in the
+  /// operator invocation, and if so return corresponding parameter.
+  Optional<AnyFunctionType::Param> getOperatorParameterFor(Expr *expr) const;
 };
 
 /// Diagnose errors associated with rvalues in positions

lib/Sema/CSSimplify.cpp

@@ -1925,6 +1925,16 @@ repairFailures(ConstraintSystem &cs, Type lhs, Type rhs,
 
   auto &elt = path.back();
   switch (elt.getKind()) {
+  case ConstraintLocator::LValueConversion:
+  case ConstraintLocator::ApplyArgToParam: {
+    if (lhs->getOptionalObjectType() && !rhs->getOptionalObjectType()) {
+      conversionsOrFixes.push_back(
+          ForceOptional::create(cs, lhs, lhs->getOptionalObjectType(),
+                                cs.getConstraintLocator(locator)));
+    }
+    break;
+  }
+
   case ConstraintLocator::FunctionArgument: {
     auto *argLoc = cs.getConstraintLocator(
         locator.withPathElement(LocatorPathElt::getSynthesizedArgument(0)));

test/Constraints/optional.swift

@@ -333,3 +333,15 @@ func sr_9893_2(cString: UnsafePointer<CChar>) {
     }
   }
 }
+
+// rdar://problem/47776586 - Diagnostic refers to '&' which is not present in the source code
+func rdar47776586() {
+  func foo(_: inout Int) {}
+  var x: Int? = 0
+  foo(&x) // expected-error {{value of optional type 'Int?' must be unwrapped to a value of type 'Int'}}
+  // expected-note@-1 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}} {{7-7=(}} {{9-9=)!}}
+
+  var dict = [1: 2]
+  dict[1] += 1 // expected-error {{value of optional type 'Int?' must be unwrapped to a value of type 'Int'}}
+  // expected-note@-1 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}} {{10-10=!}}
+}

test/Driver/Inputs/crash-after-generating-pch.py

@@ -10,13 +10,17 @@
 # See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 import os
+import platform
 import signal
 import sys
 
 assert sys.argv[1] == '-frontend'
 
 if '-emit-pch' not in sys.argv:
-    os.kill(os.getpid(), signal.SIGKILL)
+    if platform.system() == 'Windows':
+        exit(-2)
+    else:
+        os.kill(os.getpid(), signal.SIGKILL)
 
 outputFile = sys.argv[sys.argv.index('-o') + 1]
 

test/Driver/batch_mode.swift

@@ -1,5 +1,5 @@
 // Windows does not support batch-mode yet
-// XFAIL: win32
+// XFAIL: windows
 //
 // RUN: %empty-directory(%t)
 // RUN: touch %t/file-01.swift %t/file-02.swift %t/file-03.swift %t/file-04.swift %t/file-05.swift

test/Driver/batch_mode_aux_file_order.swift

@@ -1,5 +1,5 @@
 // Batch-mode is not supported on Windows yet
-// XFAIL: win32
+// XFAIL: windows
 //
 // When multiple additional-outputs on the same command-line are no longer
 // supported (i.e. when we've moved to mandatory use of output file maps for