Merge pull request #4658 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsSema.def

@@ -288,9 +288,12 @@ FIXIT(insert_closure_return_type_placeholder,
 NOTE(use_of_anon_closure_param,none,
      "anonymous closure parameter %0 is used here", (Identifier))
 
-ERROR(incorrect_explicit_closure_result,none,
+ERROR(incorrect_explicit_closure_result_vs_contextual_type,none,
       "declared closure result %0 is incompatible with contextual type %1",
       (Type, Type))
+ERROR(incorrect_explicit_closure_result_vs_return_type,none,
+      "declared closure result %0 is incompatible with return type %1",
+      (Type, Type))
 
 ERROR(unsupported_closure_attr,none,
       "%select{attribute |}0 '%1' is not supported on a closure",

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -54,6 +54,9 @@ SIMPLE_LOCATOR_PATH_ELT(AutoclosureResult)
 /// The result of a closure.
 SIMPLE_LOCATOR_PATH_ELT(ClosureResult)
 
+/// FIXME: Misleading name: this locator is used only for single-expression
+/// closure returns.
+///
 /// The type of a closure body.
 CUSTOM_LOCATOR_PATH_ELT(ClosureBody)
 

lib/ClangImporter/ImportDecl.cpp

@@ -2189,12 +2189,31 @@ namespace {
 
               Impl.markUnavailable(MD, "use .pointee property");
               MD->overwriteAccess(AccessLevel::Private);
+            } else if (cxxOperatorKind ==
+                       clang::OverloadedOperatorKind::OO_PlusPlus) {
+              auto selfTy = result->getSelfInterfaceType();
+              auto returnTy =
+                  MD->getResultInterfaceType()->getAnyPointerElementType();
+              if (cxxMethod->param_empty() &&
+                  selfTy->getCanonicalType() == returnTy->getCanonicalType()) {
+                // This is a pre-increment operator. We synthesize a
+                // non-mutating function called `successor() -> Self`.
+                FuncDecl *successorFunc = synthesizer.makeSuccessorFunc(MD);
+                result->addMember(successorFunc);
+
+                Impl.markUnavailable(MD, "use .successor()");
+              } else {
+                Impl.markUnavailable(MD, "unable to create .successor() func");
+              }
+              MD->overwriteAccess(AccessLevel::Private);
             }
             // Check if this method _is_ an overloaded operator but is not a
-            // call / subscript / dereference. Those 3 operators do not need
-            // static versions.
+            // call / subscript / dereference / increment. Those
+            // operators do not need static versions.
             else if (cxxOperatorKind !=
                          clang::OverloadedOperatorKind::OO_None &&
+                     cxxOperatorKind !=
+                         clang::OverloadedOperatorKind::OO_PlusPlus &&
                      cxxOperatorKind !=
                          clang::OverloadedOperatorKind::OO_Call &&
                      cxxOperatorKind !=

lib/ClangImporter/ImportName.cpp

@@ -1854,6 +1854,7 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
     case clang::OverloadedOperatorKind::OO_LessLess:
     case clang::OverloadedOperatorKind::OO_GreaterGreater:
     case clang::OverloadedOperatorKind::OO_EqualEqual:
+    case clang::OverloadedOperatorKind::OO_PlusPlus:
     case clang::OverloadedOperatorKind::OO_ExclaimEqual:
     case clang::OverloadedOperatorKind::OO_LessEqual:
     case clang::OverloadedOperatorKind::OO_GreaterEqual:

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -144,7 +144,7 @@ SwiftDeclSynthesizer::createVarWithPattern(DeclContext *dc, Identifier name,
                                            VarDecl::Introducer introducer,
                                            bool isImplicit, AccessLevel access,
                                            AccessLevel setterAccess) {
-  ASTContext &ctx = ImporterImpl.SwiftContext;
+  ASTContext &ctx = dc->getASTContext();
 
   // Create a variable to store the underlying value.
   auto var = new (ctx) VarDecl(
@@ -1720,6 +1720,97 @@ VarDecl *SwiftDeclSynthesizer::makeDereferencedPointeeProperty(
   return result;
 }
 
+// MARK: C++ increment operator
+
+/// Synthesizer callback for a successor function.
+///
+/// \code
+/// var __copy: Self
+/// __copy = self
+/// __copy.__operatorPlusPlus()
+/// return __copy
+/// \endcode
+static std::pair<BraceStmt *, bool>
+synthesizeSuccessorFuncBody(AbstractFunctionDecl *afd, void *context) {
+  auto successorDecl = cast<FuncDecl>(afd);
+  auto incrementImpl = static_cast<FuncDecl *>(context);
+
+  ASTContext &ctx = successorDecl->getASTContext();
+  auto emptyTupleTy = TupleType::getEmpty(ctx);
+  auto returnTy = successorDecl->getResultInterfaceType();
+
+  auto selfDecl = successorDecl->getImplicitSelfDecl();
+  auto selfRefExpr = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
+                                           /*implicit*/ true);
+  selfRefExpr->setType(selfDecl->getInterfaceType());
+
+  // Create a `__copy` variable.
+  VarDecl *copyDecl = nullptr;
+  PatternBindingDecl *patternDecl = nullptr;
+  std::tie(copyDecl, patternDecl) = SwiftDeclSynthesizer::createVarWithPattern(
+      successorDecl, ctx.getIdentifier("__copy"), returnTy,
+      VarDecl::Introducer::Var,
+      /*isImplicit*/ true, AccessLevel::Public, AccessLevel::Public);
+
+  auto copyRefLValueExpr = new (ctx) DeclRefExpr(copyDecl, DeclNameLoc(),
+                                                 /*implicit*/ true);
+  copyRefLValueExpr->setType(LValueType::get(copyDecl->getInterfaceType()));
+
+  auto inoutCopyExpr = new (ctx) InOutExpr(
+      SourceLoc(), copyRefLValueExpr,
+      successorDecl->mapTypeIntoContext(copyDecl->getValueInterfaceType()),
+      /*isImplicit*/ true);
+  inoutCopyExpr->setType(InOutType::get(copyDecl->getInterfaceType()));
+
+  // Copy `self` to `__copy`.
+  auto copyAssignExpr = new (ctx) AssignExpr(copyRefLValueExpr, SourceLoc(),
+                                             selfRefExpr, /*implicit*/ true);
+  copyAssignExpr->setType(emptyTupleTy);
+
+  // Call `operator++`.
+  auto incrementExpr = createAccessorImplCallExpr(incrementImpl, inoutCopyExpr);
+
+  auto copyRefRValueExpr = new (ctx) DeclRefExpr(copyDecl, DeclNameLoc(),
+                                                 /*implicit*/ true);
+  copyRefRValueExpr->setType(copyDecl->getInterfaceType());
+
+  auto returnStmt = new (ctx) ReturnStmt(SourceLoc(), copyRefRValueExpr,
+                                         /*implicit*/ true);
+
+  auto body = BraceStmt::create(ctx, SourceLoc(),
+                                {
+                                    copyDecl,
+                                    patternDecl,
+                                    copyAssignExpr,
+                                    incrementExpr,
+                                    returnStmt,
+                                },
+                                SourceLoc());
+  return {body, /*isTypeChecked*/ true};
+}
+
+FuncDecl *SwiftDeclSynthesizer::makeSuccessorFunc(FuncDecl *incrementFunc) {
+  auto &ctx = ImporterImpl.SwiftContext;
+  auto dc = incrementFunc->getDeclContext();
+
+  auto returnTy = incrementFunc->getImplicitSelfDecl()->getInterfaceType();
+
+  auto nameId = ctx.getIdentifier("successor");
+  auto *params = ParameterList::createEmpty(ctx);
+  DeclName name(ctx, DeclBaseName(nameId), params);
+
+  auto result = FuncDecl::createImplicit(
+      ctx, StaticSpellingKind::None, name, SourceLoc(),
+      /*Async*/ false, /*Throws*/ false,
+      /*GenericParams*/ nullptr, params, returnTy, dc);
+
+  result->setAccess(AccessLevel::Public);
+  result->setIsDynamic(false);
+  result->setBodySynthesizer(synthesizeSuccessorFuncBody, incrementFunc);
+
+  return result;
+}
+
 // MARK: C++ arithmetic operators
 
 static std::pair<BraceStmt *, bool>

lib/ClangImporter/SwiftDeclSynthesizer.h

@@ -51,7 +51,14 @@ class SwiftDeclSynthesizer {
       : ImporterImpl(Impl) {}
 
   /// Create a typedpattern(namedpattern(decl))
-  Pattern *createTypedNamedPattern(VarDecl *decl);
+  static Pattern *createTypedNamedPattern(VarDecl *decl);
+
+  /// Create a var member for this struct, along with its pattern binding, and
+  /// add it as a member.
+  static std::pair<VarDecl *, PatternBindingDecl *>
+  createVarWithPattern(DeclContext *dc, Identifier name, Type ty,
+                       VarDecl::Introducer introducer, bool isImplicit,
+                       AccessLevel access, AccessLevel setterAccess);
 
   /// Create a new named constant with the given value.
   ///
@@ -272,6 +279,10 @@ class SwiftDeclSynthesizer {
   /// \return computed property declaration
   VarDecl *makeDereferencedPointeeProperty(FuncDecl *dereferenceFunc);
 
+  /// Given a C++ pre-increment operator (`operator++()`). create a non-mutating
+  /// function `successor() -> Self`.
+  FuncDecl *makeSuccessorFunc(FuncDecl *incrementFunc);
+
   FuncDecl *makeOperator(FuncDecl *operatorMethod,
                          clang::CXXMethodDecl *clangOperator);
 
@@ -280,13 +291,6 @@ class SwiftDeclSynthesizer {
 
 private:
   Type getConstantLiteralType(Type type, ConstantConvertKind convertKind);
-
-  /// Create a var member for this struct, along with its pattern binding, and
-  /// add it as a member.
-  std::pair<VarDecl *, PatternBindingDecl *>
-  createVarWithPattern(DeclContext *dc, Identifier name, Type ty,
-                       VarDecl::Introducer introducer, bool isImplicit,
-                       AccessLevel access, AccessLevel setterAccess);
 };
 
 } // namespace swift

lib/Sema/CSApply.cpp

@@ -9189,12 +9189,13 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
     return None;
 
   if (isDebugMode()) {
-  // If we had partially type-checked expressions, lets print
-  // fully type-checked expression after processDelayed is done.
-    if (needsPostProcessing) {
+    // If we had partially type-checked expressions, lets print
+    // fully type-checked target after processDelayed is done.
+    auto node = target.getAsASTNode();
+    if (node && needsPostProcessing) {
       auto &log = llvm::errs();
-      log << "---Fully type-checked expression---\n";
-      resultTarget->getAsExpr()->dump(log);
+      log << "---Fully type-checked target---\n";
+      node.dump(log);
       log << "\n";
     }
   }

lib/Sema/CSDiagnostics.cpp

@@ -2335,17 +2335,32 @@ bool ContextualFailure::diagnoseAsError() {
   auto toType = getToType();
 
   Diag<Type, Type> diagnostic;
-  switch (path.back().getKind()) {
+
+  const auto lastPathEltKind = path.back().getKind();
+  switch (lastPathEltKind) {
   case ConstraintLocator::ClosureBody:
   case ConstraintLocator::ClosureResult: {
     auto *closure = castToExpr<ClosureExpr>(getRawAnchor());
     if (closure->hasExplicitResultType() &&
         closure->getExplicitResultTypeRepr()) {
       auto resultRepr = closure->getExplicitResultTypeRepr();
-      emitDiagnosticAt(resultRepr->getStartLoc(),
-                       diag::incorrect_explicit_closure_result, fromType,
-                       toType)
-          .fixItReplace(resultRepr->getSourceRange(), toType.getString());
+
+      if (lastPathEltKind == ConstraintLocator::ClosureBody) {
+        // The conflict is between the return type and the declared result type.
+        emitDiagnosticAt(resultRepr->getStartLoc(),
+                         diag::incorrect_explicit_closure_result_vs_return_type,
+                         toType, fromType)
+            .fixItReplace(resultRepr->getSourceRange(), fromType.getString());
+      } else {
+        // The conflict is between the declared result type and the
+        // contextual type.
+        emitDiagnosticAt(
+            resultRepr->getStartLoc(),
+            diag::incorrect_explicit_closure_result_vs_contextual_type,
+            fromType, toType)
+            .fixItReplace(resultRepr->getSourceRange(), toType.getString());
+      }
+
       return true;
     }
 

stdlib/public/Concurrency/DispatchGlobalExecutor.inc

@@ -24,7 +24,9 @@
 
 #if SWIFT_CONCURRENCY_ENABLE_DISPATCH
 #include <dispatch/dispatch.h>
-#if !defined(_WIN32)
+#if defined(_WIN32)
+#include <Windows.h>
+#else
 #include <dlfcn.h>
 #endif
 #endif

test/Constraints/closures.swift

@@ -997,7 +997,7 @@ func rdar52204414() {
   let _: () -> Void = { return 42 }
   // expected-error@-1 {{cannot convert value of type 'Int' to closure result type 'Void'}}
   let _ = { () -> Void in return 42 }
-  // expected-error@-1 {{declared closure result 'Int' is incompatible with contextual type 'Void'}}
+  // expected-error@-1 {{declared closure result 'Void' is incompatible with return type 'Int'}} {{19-23=Int}}
 }
 
 // SR-12291 - trailing closure is used as an argument to the last (positionally) parameter.

test/Driver/static-stdlib-linux-lld.swift

@@ -19,6 +19,11 @@ struct LoadableIntWrapper {
   int operator()(int x, int y) {
     return value + x * y;
   }
+
+  LoadableIntWrapper &operator++() {
+    value++;
+    return *this;
+  }
 };
 
 struct LoadableBoolWrapper {
@@ -43,6 +48,26 @@ struct AddressOnlyIntWrapper {
   int operator()(int x, int y) {
     return value + x * y;
   }
+
+  AddressOnlyIntWrapper &operator++() {
+    value++;
+    return *this;
+  }
+  AddressOnlyIntWrapper operator++(int) {
+    // This shouldn't be called, since we only support pre-increment operators.
+    return AddressOnlyIntWrapper(-777);
+  }
+};
+
+struct HasPostIncrementOperator {
+  HasPostIncrementOperator operator++(int) {
+    return HasPostIncrementOperator();
+  }
+};
+
+struct HasPreIncrementOperatorWithAnotherReturnType {
+  int value = 0;
+  const int &operator++() { return value; }
 };
 
 struct HasDeletedOperator {

test/Interop/Cxx/operators/Inputs/member-inline.h

@@ -1,6 +1,7 @@
 // RUN: %target-swift-ide-test -print-module -module-to-print=MemberInline -I %S/Inputs -source-filename=x -enable-experimental-cxx-interop | %FileCheck %s
 
 // CHECK: struct LoadableIntWrapper {
+// CHECK:   func successor() -> LoadableIntWrapper
 // CHECK:   static func - (lhs: inout LoadableIntWrapper, rhs: LoadableIntWrapper) -> LoadableIntWrapper
 // CHECK:   mutating func callAsFunction() -> Int32
 // CHECK:   mutating func callAsFunction(_ x: Int32) -> Int32

test/Interop/Cxx/operators/member-inline-module-interface.swift

@@ -40,3 +40,9 @@ let nonTrivialValueByVal = nonTrivialIntArrayByVal[1]
 var diffTypesArrayByVal = DifferentTypesArrayByVal()
 let diffTypesResultIntByVal: Int32 = diffTypesArrayByVal[0]
 let diffTypesResultDoubleByVal: Double = diffTypesArrayByVal[0.5]
+
+let postIncrement = HasPostIncrementOperator()
+postIncrement.successor() // expected-error {{value of type 'HasPostIncrementOperator' has no member 'successor'}}
+
+let anotherReturnType = HasPreIncrementOperatorWithAnotherReturnType()
+anotherReturnType.successor() // expected-error {{value of type 'HasPreIncrementOperatorWithAnotherReturnType' has no member 'successor'}}