Merge branch 'main' of github.com:apple/swift into tensorflow-stage

* 'main' of github.com:apple/swift:
  [cxx-interop] Don't crash for unkown inline-operator. (swiftlang#34602)
  [cxx-interop] Support reference types in function templates. (swiftlang#34536)

Author: ainu-bot

lib/ClangImporter/ClangImporter.cpp

@@ -3677,7 +3677,7 @@ void ClangImporter::Implementation::lookupValue(
   if (name.isOperator()) {
     for (auto entry : table.lookupMemberOperators(name.getBaseName())) {
       if (isVisibleClangEntry(entry)) {
-        if (auto decl = dyn_cast<ValueDecl>(
+        if (auto decl = dyn_cast_or_null<ValueDecl>(
                 importDeclReal(entry->getMostRecentDecl(), CurrentVersion)))
           consumer.foundDecl(decl, DeclVisibilityKind::VisibleAtTopLevel);
       }

lib/ClangImporter/ImportType.cpp

@@ -1814,8 +1814,20 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     // Import the parameter type into Swift.
     Type swiftParamTy;
     bool isParamTypeImplicitlyUnwrapped = false;
-    if (auto *templateParamType =
-            dyn_cast<clang::TemplateTypeParmType>(paramTy)) {
+
+    auto referenceType = dyn_cast<clang::ReferenceType>(paramTy);
+    if (referenceType &&
+        isa<clang::TemplateTypeParmType>(referenceType->getPointeeType())) {
+      auto pointeeType = referenceType->getPointeeType();
+      auto templateParamType = cast<clang::TemplateTypeParmType>(pointeeType);
+      PointerTypeKind pointerKind = pointeeType.getQualifiers().hasConst()
+                                        ? PTK_UnsafePointer
+                                        : PTK_UnsafeMutablePointer;
+      auto genericType =
+          findGenericTypeInGenericDecls(templateParamType, genericParams);
+      swiftParamTy = genericType->wrapInPointer(pointerKind);
+    } else if (auto *templateParamType =
+                   dyn_cast<clang::TemplateTypeParmType>(paramTy)) {
       swiftParamTy =
           findGenericTypeInGenericDecls(templateParamType, genericParams);
     } else {

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

@@ -8,4 +8,8 @@ struct LoadableIntWrapper {
   }
 };
 
+struct HasDeletedOperator {
+  void operator!=(HasDeletedOperator) const = delete;
+};
+
 #endif

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

@@ -3,3 +3,6 @@
 // CHECK: struct LoadableIntWrapper {
 // CHECK:   static func - (lhs: inout LoadableIntWrapper, rhs: LoadableIntWrapper) -> LoadableIntWrapper
 // CHECK: }
+
+// CHECK: struct HasDeletedOperator {
+// CHECK: }

test/Interop/Cxx/templates/Inputs/function-templates.h

@@ -46,3 +46,9 @@ decltype(auto) testAuto(T arg) {
 template <class T> struct Dep { using TT = T; };
 
 template <class T> void useDependentType(typename Dep<T>::TT) {}
+
+template <class T> void lvalueReference(T &ref) { ref = 42; }
+
+template <class T> void constLvalueReference(const T &) {}
+
+template <class T> void forwardingReference(T &&) {}

test/Interop/Cxx/templates/function-template-module-interface.swift

@@ -6,3 +6,6 @@
 // CHECK: func passThroughConst<T>(_ value: T) -> T
 // CHECK: func returns_template<R, T, U>(_ a: T, _ b: U) -> R
 // CHECK: func cannot_infer_template<T>()
+// CHECK: func lvalueReference<T>(_ ref: UnsafeMutablePointer<T>)
+// CHECK: func constLvalueReference<T>(_: UnsafePointer<T>)
+// CHECK: func forwardingReference<T>(_: UnsafeMutablePointer<T>)

test/Interop/Cxx/templates/function-template.swift

@@ -22,6 +22,12 @@ FunctionTemplateTestSuite.test("add<T, U> where T, U == Int") {
   expectEqual(65, result)
 }
 
+FunctionTemplateTestSuite.test("lvalueReference<T> where T == Int") {
+  var value = 0
+  lvalueReference(&value)
+  expectEqual(value, 42)
+}
+
 // TODO: currently "Any" is imported as an Objective-C "id".
 // This doesn't work without the Objective-C runtime. 
 #if _runtime(_ObjC)