1 files changed, 163 insertions, 12 deletions
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index b71aafe868a..4c73fddbb53 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -13,6 +13,7 @@
 #include "clang/Sema/TemplateDeduction.h"
 #include "TreeTransform.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTLambda.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
@@ -26,7 +27,6 @@
 
 namespace clang {
   using namespace sema;
-
   /// \brief Various flags that control template argument deduction.
   ///
   /// These flags can be bitwise-OR'd together.
@@ -3607,19 +3607,37 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
   return TDK_Success;
 }
 
+/// \brief Given a function declaration (e.g. a generic lambda conversion 
+///  function) that contains an 'auto' in its result type, substitute it 
+///  with the same Deduced type that the TypeToReplaceAutoWith was deduced 
+///  with.
+static inline void 
+ReplaceAutoWithinFunctionReturnType(FunctionDecl *F, 
+                                    QualType TypeToReplaceAutoWith, Sema &S) {
+  if (TypeToReplaceAutoWith->getContainedAutoType())
+    TypeToReplaceAutoWith = TypeToReplaceAutoWith->
+        getContainedAutoType()->getDeducedType();
+
+  QualType AutoResultType = F->getResultType();
+  assert(AutoResultType->getContainedAutoType()); 
+  QualType DeducedResultType = S.SubstAutoType(AutoResultType, 
+                                               TypeToReplaceAutoWith);
+  S.Context.adjustDeducedFunctionResultType(F, DeducedResultType);
+}
 /// \brief Deduce template arguments for a templated conversion
 /// function (C++ [temp.deduct.conv]) and, if successful, produce a
 /// conversion function template specialization.
 Sema::TemplateDeductionResult
-Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
+Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate,
                               QualType ToType,
                               CXXConversionDecl *&Specialization,
                               TemplateDeductionInfo &Info) {
-  if (FunctionTemplate->isInvalidDecl())
+  if (ConversionTemplate->isInvalidDecl())
     return TDK_Invalid;
 
   CXXConversionDecl *Conv
-    = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
+    = cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl());
+
   QualType FromType = Conv->getConversionType();
 
   // Canonicalize the types for deduction.
@@ -3675,7 +3693,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
   //   type that is required as the result of the conversion (call it
   //   A) as described in 14.8.2.4.
   TemplateParameterList *TemplateParams
-    = FunctionTemplate->getTemplateParameters();
+    = ConversionTemplate->getTemplateParameters();
   SmallVector<DeducedTemplateArgument, 4> Deduced;
   Deduced.resize(TemplateParams->size());
 
@@ -3703,14 +3721,147 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
         = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
                                              P, A, Info, Deduced, TDF))
     return Result;
-
+
+  // Create an Instantiation Scope for finalizing the operator.
+  LocalInstantiationScope InstScope(*this);
+  
+  CXXMethodDecl *LambdaCallOpSpec = 0;
+  bool GenericLambdaCallOperatorHasDeducedReturnType = false;
+  
+  // Having successfully deduced and matched the type of the conversion
+  // function against the destination type, if the destination type
+  // is a ptr-to-function and the source type is a generic lambda conversion
+  // to ptr-to-function, we know that the parameters of the destination 
+  // ptr-to-function have matched successfully against those of our 
+  // lambda's conversion function.  
+  // For instance:
+  //  int (*fp)(int) = [](auto a) { return a; };
+  //     [template<class T> operator id<auto(*)(T)>() const]
+  // If it is indeed the conversion operator of a generic lambda then if
+  // not already done, create the corresponding specializations of the call 
+  // operator and the static-invoker; and if the return type is auto, 
+  // deduce the return type, and then check and see if it matches the ToType.
+
+  const bool IsGenericLambdaConversionOperator = 
+      isLambdaConversionOperator(Conv);
+  if (IsGenericLambdaConversionOperator) {
+    const Type *FromTypePtr = P.getTypePtr();
+    const Type *ToTypePtr = A.getTypePtr();
+
+    assert(P->isPointerType()); 
+    FromTypePtr = P->getPointeeType().getTypePtr();
+    assert(A->isPointerType());
+    ToTypePtr = A->getPointeeType().getTypePtr();
+    
+    CXXRecordDecl *LambdaClass = Conv->getParent();
+    assert(LambdaClass && LambdaClass->isGenericLambda()); 
+
+    const FunctionType *ToFunType = ToTypePtr->getAs<FunctionType>();
+
+    // The specialization of the Generic Lambda Call Op, instantiated
+    // using the deduced parameters from the conversion function
+    // i.e.
+    // auto L = [](auto a) { return f(a); };
+    // int (*fp)(int) = L;
+    //
+
+    CXXMethodDecl *CallOp = LambdaClass->getLambdaCallOperator();
+    QualType CallOpResultType = CallOp->getResultType(); 
+    GenericLambdaCallOperatorHasDeducedReturnType = 
+        CallOpResultType->getContainedAutoType();
+    FunctionTemplateDecl *CallOpTemplate = 
+        CallOp->getDescribedFunctionTemplate();
+
+    TemplateDeductionInfo OpInfo(Info.getLocation()); 
+    FunctionDecl *CallOpSpec = 0;
+    // Use the deduced arguments so far, to specialize our generic
+    // lambda's call operator.
+    if (TemplateDeductionResult Result
+                  = FinishTemplateArgumentDeduction(CallOpTemplate, Deduced, 
+                                                    0, CallOpSpec, OpInfo))
+      return Result;
+ 
+    bool HadToDeduceReturnTypeDuringCurrentCall = false;
+    // If we need to deduce the return type, do so (instantiates the callop).
+    if (GenericLambdaCallOperatorHasDeducedReturnType && 
+        CallOpSpec->getResultType()->isUndeducedType()) {
+      HadToDeduceReturnTypeDuringCurrentCall = true;
+      DeduceReturnType(CallOpSpec, CallOpSpec->getPointOfInstantiation(),
+                      /*Diagnose*/ true);
+    }
+    
+    LambdaCallOpSpec = cast<CXXMethodDecl>(CallOpSpec);
+    
+    // Check to see if the return type of the destination ptr-to-function
+    // matches the return type of the call operator.
+    if (!Context.hasSameType(LambdaCallOpSpec->getResultType(), 
+        ToFunType->getResultType()))
+      return TDK_NonDeducedMismatch;
+    // Since we have succeeded in matching the source and destination
+    // ptr-to-functions (now including return type), and have successfully 
+    // specialized our corresponding call operator, we are ready to
+    // specialize the static invoker with the deduced arguments of our
+    // ptr-to-function.
+    FunctionDecl *InvokerSpecialization = 0;
+    FunctionTemplateDecl *InvokerTemplate = LambdaClass->
+                    getLambdaStaticInvoker()->getDescribedFunctionTemplate();
+
+    TemplateDeductionResult Result
+      = FinishTemplateArgumentDeduction(InvokerTemplate, Deduced, 0, 
+            InvokerSpecialization, Info);
+    assert(Result == TDK_Success);
+    // Set the result type to match the corresponding call operator
+    // specialization's result type.
+    if (GenericLambdaCallOperatorHasDeducedReturnType && 
+        InvokerSpecialization->getResultType()->isUndeducedType())
+      ReplaceAutoWithinFunctionReturnType(InvokerSpecialization,
+                                LambdaCallOpSpec->getResultType(), *this);
+    
+    // Ensure that static invoker doesn't have a const qualifier.
+    // FIXME: When creating the InvokerTemplate in SemaLambda.cpp 
+    // do not use the CallOperator's TypeSourceInfo which allows
+    // the const qualifier to leak through. 
+    const FunctionProtoType *InvokerFPT = InvokerSpecialization->
+                    getType().getTypePtr()->castAs<FunctionProtoType>();
+    FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo();
+    EPI.TypeQuals = 0;
+    InvokerSpecialization->setType(Context.getFunctionType(
+        InvokerFPT->getResultType(), InvokerFPT->getArgTypes(),EPI));
+    
+    // Since the original conversion operator's parameters are the same 
+    // entities as the lambda's call operator's, we introduce a mapping
+    // from the generic to the specialized parameters of the call operators.
+    // This only needs to be done in the absence of return type deduction,
+    // since deducing the return type entails instantiation which adds
+    // the parameter mapping to the CurrentInstantiationScope. 
+    // This is necessary when transforming nested lambdas that do not
+    // capture.
+    // FIXME: This will be fixed once nested lambdas and capturing
+    // is implemented since it does require handling parameter 
+    // packs correctly which might require careful calls to
+    // SemaTemplateInstantiate::addInstantiatedParametersToScope.
+    // if (!HadToDeduceReturnTypeDuringCurrentCall) { ... }
+  }
+  
+  
   // Finish template argument deduction.
-  LocalInstantiationScope InstScope(*this);
-  FunctionDecl *Spec = 0;
-  TemplateDeductionResult Result
-    = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
-                                      Info);
-  Specialization = cast_or_null<CXXConversionDecl>(Spec);
+  FunctionDecl *ConversionSpec = 0;
+  TemplateDeductionResult Result
+        = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, 
+              ConversionSpec, Info);
+  Specialization = cast_or_null<CXXConversionDecl>(ConversionSpec);
+  if (Result == TDK_Success && GenericLambdaCallOperatorHasDeducedReturnType) {
+    // Set the return type of the conversion specialization, since even 
+    // though we have ensured that the return types are compatible, if 
+    // there is an auto in the return type of this conversion function, 
+    // replace it permanently with the return type of the deduced lambda
+    // so we don't try and deduce against it.
+    assert(LambdaCallOpSpec);
+    if (ConversionSpec->getResultType()->isUndeducedType())
+      ReplaceAutoWithinFunctionReturnType(ConversionSpec, 
+                                          LambdaCallOpSpec->getResultType(),
+                                         *this);
+  } 
   return Result;
 }