Lines Matching refs:Lambda
883 // Iterate through the stack of lambdas starting from the innermost lambda to
884 // the outermost lambda, checking if '*this' is ever captured by copy - since
887 // member function. We then start with the innermost lambda and iterate
888 // outward checking to see if any lambda performs a by-copy capture of '*this'
889 // - and if so, any nested lambda must respect the 'constness' of that
895 // since a generic lambda's call operator can be instantiated anywhere (even
899 // DeclContext chain is that it is only mature for lambda expressions
900 // enclosing generic lambda's call operators that are being instantiated.
919 // We've run out of ScopeInfos but check if CurDC is a lambda (which can
971 // This is a generic lambda call operator that is being instantiated
976 // FIXME: This looks wrong. If we're in a lambda within a lambda within a
979 // the closure type, checking whether that is itself a lambda, and if so,
980 // recursing, until we reach a class or a function that isn't a lambda
992 // If we are within a lambda's call operator, the cv-qualifiers of 'this'
993 // might need to be adjusted if the lambda or any of its enclosing lambda's
1087 // by the capturing-entity/closure (lambda/block/etc) at
1091 // closure that is a lambda, using the explicit notation:
1159 "Only a lambda can capture the enclosing object (referred to by "
1170 // For lambda expressions, build a field and an initializing expression,
1173 ThisExpr = captureThis(*this, Context, LSI->Lambda, ThisTy, Loc,
5638 // We hit this case with the lambda conversion-to-block optimization;
6352 // This is a lambda coversion to block pointer; check if the argument
6362 // For the conversion to block pointer on a lambda expression, we
6557 // delete, lambda-expr, dynamic-cast, reinterpret-cast etc...
6581 /// \brief Check if the current lambda has any potential captures
6583 /// capture. If there is a lambda that can capture a nested
6602 // lambda (within a generic outer lambda), must be captured by an
6603 // outer lambda that is enclosed within a non-dependent context.
6612 // need to check enclosing lambda's for speculative captures.
6625 // If we have a capture-capable lambda for the variable, go ahead and
6626 // capture the variable in that lambda (and all its enclosing lambdas).
6642 // error would get diagnosed when the lambda becomes capture ready.
6661 // If we have a capture-capable lambda for 'this', go ahead and capture
6662 // 'this' in that lambda (and all its enclosing lambdas).
6988 // diagnose an unexpanded pack now (will be diagnosed once lambda-expr
6995 // FIXME: This is a hack. It would be better if we pushed the lambda scope
6996 // when we parse the lambda introducer, and teach capturing (but not
6999 // lambda where we've entered the introducer but not the body, or represent a
7000 // lambda where we've entered the body, depending on where the
7031 // lambda), if there is a potential capture within the nested lambda,
7032 // have the outer capture-able lambda try and capture it.
7047 // the gnu-extension statement-expressions or even lambda-init-captures:
7062 // even if CurContext is not a lambda call operator. Refer to that Bug Report
7064 // By ensuring we are in the context of a lambda's call operator
7066 // if we are within a lambda's body); but per the comments in that
