[AST] Add a isActuallyImplicitCast() helper to the CastExpr class.

[lebedev.ri]

Summary

This is mostly factored out of D48958.
As of D49838, ImplicitCastExpr can tell whether it is a part of ExplicitCastExpr group.
But given just the CastExpr, one still has to check that it is not ExplicitCastExpr itself,
before using ImplicitCastExpr::getIsPartOfExplicitCast().
Thus, it makes sense to factor out it into a helper function in CastExpr baseclass.

This indeed does not have tests. Would be happy to add those, if needed and told how to write those.

[erichkeane]

I'm not sure that this logic requires a separate function. Since you've fixed the getIsPartOfExplicitCast logic correctly, it is pretty simple...

include/clang/AST/Expr.h

2856

These two sentences are both sentence fragments and should likely be joined.

A suggested alternative?
"An explicit cast corresponds to a cast written in the source code, while an implicit cast is materialized for the purposes of automatic conversions.

3022

Are you asking or telling? I'd prefer this comment not be here, or explain the logic.

[lebedev.ri]

Comment fine-tuning.

In D49844#1176639, @erichkeane wrote:

I'm not sure that this logic requires a separate function. Since you've fixed the getIsPartOfExplicitCast logic correctly, it is pretty simple...

Certainly. I can totally inline it into the caller,
but i *think* @rsmith suggested that such functionality should be present, so i'll wait for him to comment.

[erichkeane]

If @rsmith requested this, I'm fine with it then.

[rsmith]

What I requested was that either we make CastExpr::isPartOfExplicitCast() return true for CastExprs that are not ImplicitCastExprs, or that we move isPartOfExplicitCast do the ImplicitCastExpr derived class. We don't need to do both, and since we're doing the latter in D49838, we don't need to do anything else. (Essentially, my request was to fix the bug that CastExpr::isPartOfExplicitCast() incorrectly returned false when called on an explicit cast expression, and I don't mind which way we fix it.)

[lebedev.ri]

In D49844#1177273, @rsmith wrote:

What I requested was that either we make CastExpr::isPartOfExplicitCast() return true for CastExprs that are not ImplicitCastExprs, or that we move isPartOfExplicitCast do the ImplicitCastExpr derived class. We don't need to do both, and since we're doing the latter in D49838, we don't need to do anything else. (Essentially, my request was to fix the bug that CastExpr::isPartOfExplicitCast() incorrectly returned false when called on an explicit cast expression, and I don't mind which way we fix it.)

Ok, no problem at atll, so i have read too much into it :)
I will then simply inline this into the only caller.

include/clang/AST/Expr.h

public:
   /// Retrieve the cast subexpression as it was written in the source
   /// code, looking through any implicit casts or other intermediate nodes
   /// introduced by semantic analysis.
   Expr *getSubExprAsWritten();
   const Expr *getSubExprAsWritten() const {
     return const_cast<CastExpr *>(this)->getSubExprAsWritten();
   }
 
+  /// There are two global types of casts - implicit and explicit. An explicit
+  /// cast corresponds to a cast written in the source code, while an implicit
+  /// cast is materialized for the purposes of automatic conversions.
+  /// But in AST, some explicit casts are represented as ExplicitCastExpr plus
+  /// one or more immediate ImplicitCastExpr (i.e. with nothing inbetween).
+  /// This function returns false if this cast is either an ExplicitCastExpr
+  /// itself, or it is a part of the ExplicitCastExpr group.
+  bool isActuallyImplicitCast() const;
+
   /// If this cast applies a user-defined conversion, retrieve the conversion
   /// function that it invokes.
   NamedDecl *getConversionFunction() const;
 
   typedef CXXBaseSpecifier **path_iterator;
   typedef const CXXBaseSpecifier * const *path_const_iterator;
   bool path_empty() const { return CastExprBits.BasePathSize == 0; }
   unsigned path_size() const { return CastExprBits.BasePathSize; }
public:
   QualType getTypeAsWritten() const { return TInfo->getType(); }
 
   static bool classof(const Stmt *T) {
      return T->getStmtClass() >= firstExplicitCastExprConstant &&
             T->getStmtClass() <= lastExplicitCastExprConstant;
   }
 };
 
+inline bool CastExpr::isActuallyImplicitCast() const {
+  if (auto *IC = dyn_cast<ImplicitCastExpr>(this))
+    return !IC->getIsPartOfExplicitCast();
+  assert(isa<ExplicitCastExpr>(this) && "it has to be Explicit cast then.");
+  return false; // Explicit cast is clearly not an Implicit cast.
+}
+
 /// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
 /// cast in C++ (C++ [expr.cast]), which uses the syntax
 /// (Type)expr. For example: @c (int)f.
 class CStyleCastExpr final
     : public ExplicitCastExpr,
       private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *> {
   SourceLocation LPLoc; // the location of the left paren
   SourceLocation RPLoc; // the location of the right paren