1 files changed, 22 insertions, 73 deletions

diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index bec956b6d72..977d0132b7e 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -594,11 +594,6 @@ public:
   /// \brief Transform the captures and body of a lambda expression.
   ExprResult TransformLambdaScope(LambdaExpr *E, CXXMethodDecl *CallOperator);
 
-  TemplateParameterList *TransformTemplateParameterList(
-        TemplateParameterList *TPL) {
-    return TPL;
-  }
-
   ExprResult TransformAddressOfOperand(Expr *E);
   ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
                                                 bool IsAddressOfOperand);
@@ -4578,19 +4573,6 @@ template<typename Derived>
 QualType TreeTransform<Derived>::TransformDecltypeType(TypeLocBuilder &TLB,
                                                        DecltypeTypeLoc TL) {
   const DecltypeType *T = TL.getTypePtr();
-  // Don't transform a decltype construct that has already been transformed 
-  // into a non-dependent type.
-  // Allows the following to compile:
-  // auto L = [](auto a) {
-  //   return [](auto b) ->decltype(a) {
-  //     return b;
-  //  };
-  //};  
-  if (!T->isInstantiationDependentType()) {
-    DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(TL.getType());
-    NewTL.setNameLoc(TL.getNameLoc());
-    return NewTL.getType();
-  }
 
   // decltype expressions are not potentially evaluated contexts
   EnterExpressionEvaluationContext Unevaluated(SemaRef, Sema::Unevaluated, 0,
@@ -8302,27 +8284,24 @@ template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
  
-  getSema().PushLambdaScope();
-  LambdaScopeInfo *LSI = getSema().getCurLambda();
-  TemplateParameterList *const OrigTPL = E->getTemplateParameterList();
-  TemplateParameterList *NewTPL = 0;
-  // Transform the template parameters, and add them to the 
-  // current instantiation scope.
-  if (OrigTPL) {
-      NewTPL = getDerived().TransformTemplateParameterList(OrigTPL);
-  }
-  LSI->GLTemplateParameterList = NewTPL;
-   // Transform the type of the lambda parameters and start the definition of
-   // the lambda itself.
-  TypeSourceInfo *OldCallOpTSI = E->getCallOperator()->getTypeSourceInfo(); 
-  TypeSourceInfo *NewCallOpTSI = TransformType(OldCallOpTSI);
-  if (!NewCallOpTSI)
+  // FIXME: Implement nested generic lambda transformations.
+  if (E->isGenericLambda()) {
+    getSema().Diag(E->getIntroducerRange().getBegin(), 
+      diag::err_glambda_not_fully_implemented) 
+      << " template transformation of generic lambdas not implemented yet";
+    return ExprError();
+  }
+  // Transform the type of the lambda parameters and start the definition of
+  // the lambda itself.
+  TypeSourceInfo *MethodTy
+    = TransformType(E->getCallOperator()->getTypeSourceInfo());
+  if (!MethodTy)
     return ExprError();
 
   // Create the local class that will describe the lambda.
   CXXRecordDecl *Class
     = getSema().createLambdaClosureType(E->getIntroducerRange(),
-                                        NewCallOpTSI,
+                                        MethodTy,
                                         /*KnownDependent=*/false);
   getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
 
@@ -8334,49 +8313,19 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
         E->getCallOperator()->param_size(),
         0, ParamTypes, &Params))
     return ExprError();
-
+  getSema().PushLambdaScope();
+  LambdaScopeInfo *LSI = getSema().getCurLambda();
+  // TODO: Fix for nested lambdas
+  LSI->GLTemplateParameterList = 0;
   // Build the call operator.
-  CXXMethodDecl *NewCallOperator
+  CXXMethodDecl *CallOperator
     = getSema().startLambdaDefinition(Class, E->getIntroducerRange(),
-                                      NewCallOpTSI,
+                                      MethodTy,
                                       E->getCallOperator()->getLocEnd(),
                                       Params);
-  LSI->CallOperator = NewCallOperator;
-  // Fix the Decl Contexts of the parameters within the call op function 
-  // prototype.
-  getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
-  
-  TypeLoc NewCallOpTL = NewCallOpTSI->getTypeLoc();
-  FunctionProtoTypeLoc NewFPTL = NewCallOpTL.castAs<FunctionProtoTypeLoc>();
-  ParmVarDecl **NewParamDeclArray = NewFPTL.getParmArray();
-  const unsigned NewNumArgs = NewFPTL.getNumArgs();
-  for (unsigned I = 0; I < NewNumArgs; ++I) {
-      NewParamDeclArray[I]->setOwningFunction(NewCallOperator);
-  }
-  // If this is a non-generic lambda, the parameters do not get added to the
-  // current instantiation scope, so add them.  This feels kludgey.
-  // Anyway, it allows the following to compile when the enclosing template
-  // is specialized and the entire lambda expression has to be
-  // transformed.  Without this FindInstantiatedDecl causes an assertion.
-  // template<class T> void foo(T t) {
-  //    auto L = [](auto a) { 
-  //      auto M = [](char b) { <-- note: non-generic lambda
-  //        auto N = [](auto c) {
-  //          int x = sizeof(a);        
-  //          x = sizeof(b); <-- specifically this line
-  //          x = sizeof(c);
-  //        };  
-  //      };    
-  //    };
-  //  }
-  //  foo('a');
-  //
-  if (!E->isGenericLambda()) {
-    for (unsigned I = 0; I < NewNumArgs; ++I)
-      SemaRef.CurrentInstantiationScope->InstantiatedLocal(
-                                   NewParamDeclArray[I], NewParamDeclArray[I]);
-  }
-  return getDerived().TransformLambdaScope(E, NewCallOperator);
+  getDerived().transformAttrs(E->getCallOperator(), CallOperator);
+
+  return getDerived().TransformLambdaScope(E, CallOperator);
 }
 
 template<typename Derived>