[CSApply] Don't attempt to mark autoclosures as non-implicit

While building an initializer call the declaration reference
should have the same implicitness as the call when it doesn't
require thunking, otherwise don't attempt to mark autoclosures
as non-implicit because it could break assumptions elsewhere.

(cherry picked from commit 37e2f37)

Author: xedin

lib/Sema/CSApply.cpp

@@ -8669,7 +8669,10 @@ Expr *ExprRewriter::finishApply(ApplyExpr *apply, Type openedType,
                                  AccessSemantics::Ordinary);
   if (!declRef)
     return nullptr;
-  declRef->setImplicit(apply->isImplicit());
+
+  if (!isa<AutoClosureExpr>(declRef))
+    declRef->setImplicit(apply->isImplicit());
+
   apply->setFn(declRef);
 
   // Tail-recur to actually call the constructor.

test/Concurrency/attr_execution/adoption_mode.swift

@@ -272,3 +272,22 @@ do {
   }
 }
 
+// The compiler used to mark autoclosure in `MyThing` reference as "non-implicit"
+// which caused a crash in migration mode because it assumes that autoclosures
+// are always implicit.
+do {
+  struct Other {
+    init(test: Int) {}
+  }
+
+  struct S<T> {
+    typealias MyThing = Other
+    var value: T
+  }
+
+  func test(c: S<Int?>) {
+    _ = c.value.map {
+      type(of: c).MyThing(test: $0) // Ok (used to crash due to autoclosure use)
+    }
+  }
+}