r191641 - Fix windows newlines :(
Faisal Vali
faisalv at yahoo.com
Sun Sep 29 10:08:33 PDT 2013
Author: faisalv
Date: Sun Sep 29 12:08:32 2013
New Revision: 191641
URL: http://llvm.org/viewvc/llvm-project?rev=191641&view=rev
Log:
Fix windows newlines :(
Modified:
cfe/trunk/lib/AST/DeclCXX.cpp
cfe/trunk/lib/Sema/SemaDeclCXX.cpp
cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp
Modified: cfe/trunk/lib/AST/DeclCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/DeclCXX.cpp?rev=191641&r1=191640&r2=191641&view=diff
==============================================================================
--- cfe/trunk/lib/AST/DeclCXX.cpp (original)
+++ cfe/trunk/lib/AST/DeclCXX.cpp Sun Sep 29 12:08:32 2013
@@ -950,33 +950,33 @@ bool CXXRecordDecl::isGenericLambda() co
CXXMethodDecl* CXXRecordDecl::getLambdaCallOperator() const {
if (!isLambda()) return 0;
- DeclarationName Name =
- getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
+ DeclarationName Name =
+ getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
DeclContext::lookup_const_result Calls = lookup(Name);
-
- assert(!Calls.empty() && "Missing lambda call operator!");
- assert(Calls.size() == 1 && "More than one lambda call operator!");
-
- NamedDecl *CallOp = Calls.front();
- if (FunctionTemplateDecl *CallOpTmpl =
- dyn_cast<FunctionTemplateDecl>(CallOp))
- return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
+
+ assert(!Calls.empty() && "Missing lambda call operator!");
+ assert(Calls.size() == 1 && "More than one lambda call operator!");
+
+ NamedDecl *CallOp = Calls.front();
+ if (FunctionTemplateDecl *CallOpTmpl =
+ dyn_cast<FunctionTemplateDecl>(CallOp))
+ return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
return cast<CXXMethodDecl>(CallOp);
}
CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
if (!isLambda()) return 0;
- DeclarationName Name =
- &getASTContext().Idents.get(getLambdaStaticInvokerName());
+ DeclarationName Name =
+ &getASTContext().Idents.get(getLambdaStaticInvokerName());
DeclContext::lookup_const_result Invoker = lookup(Name);
- if (Invoker.empty()) return 0;
- assert(Invoker.size() == 1 && "More than one static invoker operator!");
- NamedDecl *InvokerFun = Invoker.front();
- if (FunctionTemplateDecl *InvokerTemplate =
- dyn_cast<FunctionTemplateDecl>(InvokerFun))
- return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
-
+ if (Invoker.empty()) return 0;
+ assert(Invoker.size() == 1 && "More than one static invoker operator!");
+ NamedDecl *InvokerFun = Invoker.front();
+ if (FunctionTemplateDecl *InvokerTemplate =
+ dyn_cast<FunctionTemplateDecl>(InvokerFun))
+ return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
+
return cast<CXXMethodDecl>(InvokerFun);
}
Modified: cfe/trunk/lib/Sema/SemaDeclCXX.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclCXX.cpp?rev=191641&r1=191640&r2=191641&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaDeclCXX.cpp (original)
+++ cfe/trunk/lib/Sema/SemaDeclCXX.cpp Sun Sep 29 12:08:32 2013
@@ -10435,7 +10435,7 @@ void Sema::DefineImplicitLambdaToBlockPo
SourceLocation CurrentLocation,
CXXConversionDecl *Conv)
{
- assert(!Conv->getParent()->isGenericLambda());
+ assert(!Conv->getParent()->isGenericLambda());
Conv->markUsed(Context);
Modified: cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp?rev=191641&r1=191640&r2=191641&view=diff
==============================================================================
--- cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp (original)
+++ cfe/trunk/lib/Sema/SemaTemplateDeduction.cpp Sun Sep 29 12:08:32 2013
@@ -3607,10 +3607,10 @@ Sema::DeduceTemplateArguments(FunctionTe
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.
+/// \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) {
@@ -3618,9 +3618,9 @@ ReplaceAutoWithinFunctionReturnType(Func
TypeToReplaceAutoWith = TypeToReplaceAutoWith->
getContainedAutoType()->getDeducedType();
- QualType AutoResultType = F->getResultType();
- assert(AutoResultType->getContainedAutoType());
- QualType DeducedResultType = S.SubstAutoType(AutoResultType,
+ QualType AutoResultType = F->getResultType();
+ assert(AutoResultType->getContainedAutoType());
+ QualType DeducedResultType = S.SubstAutoType(AutoResultType,
TypeToReplaceAutoWith);
S.Context.adjustDeducedFunctionResultType(F, DeducedResultType);
}
@@ -3721,101 +3721,101 @@ Sema::DeduceTemplateArguments(FunctionTe
= DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
P, A, Info, Deduced, TDF))
return Result;
-
- // Create an Instantiation Scope for finalizing the operator.
- LocalInstantiationScope InstScope(*this);
-
- CXXMethodDecl *LambdaCallOpSpec = 0;
+
+ // 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);
+
+ // 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
@@ -3826,41 +3826,41 @@ Sema::DeduceTemplateArguments(FunctionTe
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.
+ 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.
- 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);
+ 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;
}
More information about the cfe-commits
mailing list