Home | History | Annotate | Line # | Download | only in AST 
      1 //===--- ASTLambda.h - Lambda Helper Functions --------------*- C++ -*-===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 ///
      9 /// \file
     10 /// This file provides some common utility functions for processing
     11 /// Lambda related AST Constructs.
     12 ///
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_CLANG_AST_ASTLAMBDA_H
     16 #define LLVM_CLANG_AST_ASTLAMBDA_H
     17 
     18 #include "clang/AST/DeclCXX.h"
     19 #include "clang/AST/DeclTemplate.h"
     20 
     21 namespace clang {
     22 inline StringRef getLambdaStaticInvokerName() {
     23   return "__invoke";
     24 }
     25 // This function returns true if M is a specialization, a template,
     26 // or a non-generic lambda call operator.
     27 inline bool isLambdaCallOperator(const CXXMethodDecl *MD) {
     28   const CXXRecordDecl *LambdaClass = MD->getParent();
     29   if (!LambdaClass || !LambdaClass->isLambda()) return false;
     30   return MD->getOverloadedOperator() == OO_Call;
     31 }
     32 
     33 inline bool isLambdaCallOperator(const DeclContext *DC) {
     34   if (!DC || !isa<CXXMethodDecl>(DC)) return false;
     35   return isLambdaCallOperator(cast<CXXMethodDecl>(DC));
     36 }
     37 
     38 inline bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD) {
     39   if (!MD) return false;
     40   const CXXRecordDecl *LambdaClass = MD->getParent();
     41   if (LambdaClass && LambdaClass->isGenericLambda())
     42     return isLambdaCallOperator(MD) &&
     43                     MD->isFunctionTemplateSpecialization();
     44   return false;
     45 }
     46 
     47 inline bool isLambdaConversionOperator(CXXConversionDecl *C) {
     48   return C ? C->getParent()->isLambda() : false;
     49 }
     50 
     51 inline bool isLambdaConversionOperator(Decl *D) {
     52   if (!D) return false;
     53   if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D))
     54     return isLambdaConversionOperator(Conv);
     55   if (FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(D))
     56     if (CXXConversionDecl *Conv =
     57         dyn_cast_or_null<CXXConversionDecl>(F->getTemplatedDecl()))
     58       return isLambdaConversionOperator(Conv);
     59   return false;
     60 }
     61 
     62 inline bool isGenericLambdaCallOperatorSpecialization(DeclContext *DC) {
     63   return isGenericLambdaCallOperatorSpecialization(
     64                                           dyn_cast<CXXMethodDecl>(DC));
     65 }
     66 
     67 inline bool isGenericLambdaCallOperatorOrStaticInvokerSpecialization(
     68     DeclContext *DC) {
     69   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC);
     70   if (!MD) return false;
     71   const CXXRecordDecl *LambdaClass = MD->getParent();
     72   if (LambdaClass && LambdaClass->isGenericLambda())
     73     return (isLambdaCallOperator(MD) || MD->isLambdaStaticInvoker()) &&
     74                     MD->isFunctionTemplateSpecialization();
     75   return false;
     76 }
     77 
     78 
     79 // This returns the parent DeclContext ensuring that the correct
     80 // parent DeclContext is returned for Lambdas
     81 inline DeclContext *getLambdaAwareParentOfDeclContext(DeclContext *DC) {
     82   if (isLambdaCallOperator(DC))
     83     return DC->getParent()->getParent();
     84   else
     85     return DC->getParent();
     86 }
     87 
     88 } // clang
     89 
     90 #endif
     91