TypeReconstruction: Replace FunctionType::getOld() with explicit decomposeInput()

This is not any "better" because we also want to eventually
remove decomposeInput() too. However we're planning on
scrapping TypeReconstruction altogether so its unlikely that
refactoring this to do the right thing will be worth it.

Instead just inline what getOld() does so we can move forward.

Author: slavapestov

lib/IDE/TypeReconstruction.cpp

@@ -1466,15 +1466,15 @@ static void CreateFunctionType(ASTContext *ast,
                                bool escaping,
                                bool throws,
                                VisitNodeResult &result) {
-  Type arg_clang_type;
-  Type return_clang_type;
+  Type arg_type;
+  Type return_type;
 
   switch (arg_type_result._types.size()) {
   case 0:
-    arg_clang_type = TupleType::getEmpty(*ast);
+    arg_type = TupleType::getEmpty(*ast);
     break;
   case 1:
-    arg_clang_type = arg_type_result._types.front().getPointer();
+    arg_type = arg_type_result._types.front().getPointer();
     break;
   default:
     result._error = "too many argument types for a function type";
@@ -1483,22 +1483,28 @@ static void CreateFunctionType(ASTContext *ast,
 
   switch (return_type_result._types.size()) {
   case 0:
-    return_clang_type = TupleType::getEmpty(*ast);
+    return_type = TupleType::getEmpty(*ast);
     break;
   case 1:
-    return_clang_type = return_type_result._types.front().getPointer();
+    return_type = return_type_result._types.front().getPointer();
     break;
   default:
     result._error = "too many return types for a function type";
     break;
   }
 
-  if (arg_clang_type && return_clang_type) {
-    result._types.push_back(
-        FunctionType::getOld(arg_clang_type, return_clang_type,
-                            FunctionType::ExtInfo()
-                              .withNoEscape(!escaping)
-                              .withThrows(throws)));
+  if (arg_type && return_type) {
+    // FIXME: We need to either refactor this code to build function parameters
+    // directly, or better yet, scrap TypeReconstruction altogether in favor of
+    // TypeDecoder which already does the right thing.
+    SmallVector<AnyFunctionType::Param, 8> params;
+    AnyFunctionType::decomposeInput(arg_type, params);
+
+    auto ext_info =
+      FunctionType::ExtInfo()
+        .withNoEscape(!escaping)
+        .withThrows(throws);
+    result._types.push_back(FunctionType::get(params, return_type, ext_info));
   }
 }