[🍒][cxx-interop] Use translation unit scope when doing lookups; disambiguate math functions.

lib/ClangImporter/ClangAdapter.cpp

@@ -554,7 +554,7 @@ clang::TypedefNameDecl *importer::findSwiftNewtype(const clang::NamedDecl *decl,
     clang::LookupResult lookupResult(clangSema, notificationName,
                                      clang::SourceLocation(),
                                      clang::Sema::LookupOrdinaryName);
-    if (!clangSema.LookupName(lookupResult, nullptr))
+    if (!clangSema.LookupName(lookupResult, clangSema.TUScope))
       return nullptr;
     auto nsDecl = lookupResult.getAsSingle<clang::TypedefNameDecl>();
     if (!nsDecl)

lib/ClangImporter/ClangImporter.cpp

@@ -2712,7 +2712,7 @@ ClangImporter::Implementation::lookupTypedef(clang::DeclarationName name) {
                                    clang::SourceLocation(),
                                    clang::Sema::LookupOrdinaryName);
 
-  if (sema.LookupName(lookupResult, /*scope=*/nullptr)) {
+  if (sema.LookupName(lookupResult, sema.TUScope)) {
     for (auto decl : lookupResult) {
       if (auto typedefDecl =
           dyn_cast<clang::TypedefNameDecl>(decl->getUnderlyingDecl()))

lib/ClangImporter/ImportDecl.cpp

@@ -3197,19 +3197,30 @@ namespace {
         // presence in the C++ standard library will cause overloading
         // ambiguities or other type checking errors in Swift.
         auto isAlternativeCStdlibFunctionFromTextualHeader =
-            [](const clang::FunctionDecl *d) -> bool {
+            [this](const clang::FunctionDecl *d) -> bool {
           // stdlib.h might be a textual header in libc++'s module map.
           // in this case, check for known ambiguous functions by their name
           // instead of checking if they come from the `std` module.
           if (!d->getDeclName().isIdentifier())
             return false;
-          return d->getName() == "abs" || d->getName() == "div";
+          if (d->getName() == "abs" || d->getName() == "div")
+            return true;
+          if (Impl.SwiftContext.LangOpts.Target.isOSDarwin())
+            return d->getName() == "strstr" || d->getName() == "sin" ||
+                   d->getName() == "cos" || d->getName() == "exit";
+          return false;
         };
-        if (decl->getOwningModule() &&
-            (decl->getOwningModule()
-                     ->getTopLevelModule()
-                     ->getFullModuleName() == "std" ||
-             isAlternativeCStdlibFunctionFromTextualHeader(decl))) {
+        auto topLevelModuleEq =
+            [](const clang::FunctionDecl *d, StringRef n) -> bool {
+          return d->getOwningModule() &&
+                 d->getOwningModule()
+                    ->getTopLevelModule()
+                    ->getFullModuleName() == n;
+        };
+        if (topLevelModuleEq(decl, "std")) {
+          if (isAlternativeCStdlibFunctionFromTextualHeader(decl)) {
+            return nullptr;
+          }
           auto filename =
               Impl.getClangPreprocessor().getSourceManager().getFilename(
                   decl->getLocation());
@@ -3218,6 +3229,13 @@ namespace {
             return nullptr;
           }
         }
+        // Use the exit function from _SwiftConcurrency.h as it is platform
+        // agnostic.
+        if ((topLevelModuleEq(decl, "Darwin") ||
+             topLevelModuleEq(decl, "SwiftGlibc")) &&
+            decl->getDeclName().isIdentifier() && decl->getName() == "exit") {
+          return nullptr;
+        }
       }
 
       auto dc =

lib/ClangImporter/ImportMacro.cpp

@@ -328,6 +328,8 @@ static Optional<std::pair<llvm::APSInt, Type>>
     }
 
   // Macro identifier.
+  // TODO: for some reason when in C++ mode, "hasMacroDefinition" is often
+  // false: rdar://110071334
   } else if (token.is(clang::tok::identifier) &&
              token.getIdentifierInfo()->hasMacroDefinition()) {
 
@@ -422,7 +424,7 @@ static ValueDecl *importMacro(ClangImporter::Implementation &impl,
       auto diagState = impl.getClangSema().DelayedDiagnostics.push(diagPool);
       auto parsedType = impl.getClangSema().getTypeName(identifier,
                                                         clang::SourceLocation(),
-                                                        /*scope*/nullptr);
+                                                        impl.getClangSema().TUScope);
       impl.getClangSema().DelayedDiagnostics.popWithoutEmitting(diagState);
 
       if (parsedType && diagPool.empty()) {

test/ClangImporter/cf.swift

@@ -1,5 +1,7 @@
 // RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -typecheck -verify -import-cf-types -I %S/Inputs/custom-modules %s
 
+// RUN: %target-swift-frontend -disable-objc-attr-requires-foundation-module -typecheck -verify -import-cf-types -enable-experimental-cxx-interop -I %S/Inputs/custom-modules %s
+
 // REQUIRES: objc_interop
 
 import CoreCooling

test/ClangImporter/macros.swift

@@ -1,5 +1,8 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-objc-interop -typecheck -verify %s
 
+// Most of these don't pass: rdar://110071334
+// %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-cxx-interop -enable-objc-interop -typecheck -verify %s
+
 @_exported import macros
 
 func circle_area(_ radius: CDouble) -> CDouble {

test/Interop/Cxx/objc-correctness/Inputs/module.modulemap

@@ -12,3 +12,9 @@ module CxxClassWithNSStringInit [extern_c] {
 module NSOptionsMangling {
   header "NSOptionsMangling.h"
 }
+
+module NSNofiticationBridging {
+  header "nsnotification-bridging.h"
+  requires objc
+  requires cplusplus
+}

test/Interop/Cxx/objc-correctness/Inputs/nsnotification-bridging.h

@@ -0,0 +1,3 @@
+#import <Foundation/Foundation.h>
+
+extern NSString * const SpaceShipNotification;

test/Interop/Cxx/objc-correctness/nsnotification-bridging-ide-test.swift

@@ -0,0 +1,7 @@
+// RUN: %target-swift-ide-test -print-module -module-to-print=NSNofiticationBridging -I %S/Inputs -source-filename=x -enable-experimental-cxx-interop -enable-objc-interop | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// CHECK: import Foundation
+
+// CHECK: let SpaceShipNotification: String

test/Interop/Cxx/stdlib/avoid-import-cxx-math.swift

@@ -5,19 +5,17 @@
 import CxxStdlib
 
 func test() {
-    let x: Float = 1.0
+    let x: Double = 1.0
     let y: Double = 2.0
 
-    // Note: we dispatch `pow(Float,Double)`
-    // to ensure we don't pick up the
-    // C++ stdlib `pow` function template.
-    // The `pow` function is still reexported
-    // from Darwin via CxxStdlib, so there are
-    // matching overloads that can be found still.
-    // Note: the error is different on Glibc instead
-    // of Darwin, so do not check the exact error.
-    let _ =  CxxStdlib.pow(x, y) // expected-error {{}}
+    let _ =  pow(x, y)
 
-    let _ = CxxStdlib.abs(x) // expected-error {{module 'CxxStdlib' has no member named 'abs'}}
-    let _ = CxxStdlib.div(x) // expected-error {{module 'CxxStdlib' has no member named 'div'}}
+    let _ = abs(x)
+    // https://github.com/apple/swift/issues/67006
+    // let _ = div(42, 2)
+    let _ = sin(x)
+    let _ = cos(x)
+    let _ = strstr("a", "aaa")
+
+    exit(0)
 }

test/Interop/Cxx/stdlib/use-swift-concurrency.swift

@@ -0,0 +1,39 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-experimental-cxx-interop -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library)
+//
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: libdispatch
+// REQUIRES: concurrency_runtime
+
+import StdlibUnittest
+
+import CxxStdlib
+import Cxx
+
+import _Concurrency
+import Dispatch
+
+@main struct Main {
+  static func main() async {
+    var ConcurrencyTestSuite = TestSuite("Concurrency")
+
+    ConcurrencyTestSuite.test("Task.sleep") {
+      let start = DispatchTime.now()
+      await Task.sleep(100_000_000)
+      let stop = DispatchTime.now()
+      expectTrue(stop >= (start + .nanoseconds(100_000_000)))
+    }
+
+    ConcurrencyTestSuite.test("Task.sleep (non-blocking)") {
+      let task = detach {
+        std.string("Hello, Swift!")
+      }
+
+      await Task.sleep(100_000_000)
+      expectEqual(await task.get(), "Hello, Swift!")
+    }
+
+    await runAllTestsAsync()
+  }
+}
+