[NFC] Adjust SmallVector.h header to workaround XL build compiler issue

[Xiangling_L]

Summary

Previously delivered a patch to workaround the building issue related to SmallVector are here:
https://reviews.llvm.org/D98265
https://reviews.llvm.org/rG8dc70bdcd0fe4efb65876dce0144d9c3386a2f07

But in order to prevent further building issues related to the usage of it in other compilation unit, this patch adjusts the llvm.h header as a workaround instead.

We will further investigate the real problem of build compiler as a follow-up.

[jsji]

If we use this workaround, can we also revert 561fb7f60ab631e712c3fb6bbeb47061222c6818 and 8dc70bdcd0fe4efb65876dce0144d9c3386a2f07 in this patch?

[RKSimon]

clang/include/clang/Basic/LLVM.h

25

Is there a better comment? "unblock the XL build compiler issue" isn't going to mean much to someone in the future....

39

Should these 2 forward declarations be removed?

[Xiangling_L]

In D98552#2623399, @jsji wrote:

If we use this workaround, can we also revert 561fb7f60ab631e712c3fb6bbeb47061222c6818 and 8dc70bdcd0fe4efb65876dce0144d9c3386a2f07 in this patch?

Good idea. Will do

[Xiangling_L]

clang/include/clang/Basic/LLVM.h

25

How about "Add this header as a workaround to prevent "too few template arguments for class template 'SmallVector' ""? Or do you have any suggestion?

39

Thanks. will do.

[Xiangling_L]

Addressed the comments;

[hubert.reinterpretcast]

Thanks @Xiangling_L and also to the other reviewers for the great comments. This LGTM.

[Xiangling_L]

clang/include/clang/Basic/LLVM.h

71

It's my bad to not wait for a build finished before updating the patch, I saw a lot of build failures as the following that seems related to the deletion here:

/data/xling/wyvern/master-external/llvm-project/clang/include/clang/Basic/Module.h:222:3: error: no template named 'SmallVector'; did you mean 'llvm::SmallVector'?
  SmallVector<UnresolvedHeaderDirective, 1> UnresolvedHeaders;
  ^~~~~~~~~~~
  llvm::SmallVector
/data/xling/wyvern/master-external/llvm-project/clang/include/clang/Basic/LLVM.h:38:42: note: 'llvm::SmallVector' declared here
  template<typename T, unsigned N> class SmallVector;
                                         ^

I will update the patch accordingly after I have a successful build and run the test.

[Xiangling_L]

Bring back two forward declarations to avoid changing pervasive SmallVector to llvm::SmallVector

[hubert.reinterpretcast]

Retained using declarations look fine. LGTM.

clang/include/clang/Basic/LLVM.h

 
 // Do not proliferate #includes here, require clients to #include their
 // dependencies.
 // Casting.h has complex templates that cannot be easily forward declared.
 #include "llvm/Support/Casting.h"
 // None.h includes an enumerator that is desired & cannot be forward declared
 // without a definition of NoneType.
 #include "llvm/ADT/None.h"
+// Add this header as a workaround to prevent `too few template arguments for
+// class template 'SmallVector'` building error with build compilers like XL.
+#include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
   // ADT's.
   class StringRef;
   class Twine;
   class VersionTuple;
   template<typename T> class ArrayRef;
   template<typename T> class MutableArrayRef;
   template<typename T> class OwningArrayRef;
   template<unsigned InternalLen> class SmallString;
   template<typename T, unsigned N> class SmallVector;
   template<typename T> class SmallVectorImpl;
   template<typename T> class Optional;
   template <class T> class Expected;
 
   template<typename T>
   struct SaveAndRestore;
 
   // Reference counting.
   template <typename T> class IntrusiveRefCntPtr;
namespace clang {
   // ADT's.
   using llvm::ArrayRef;
   using llvm::MutableArrayRef;
   using llvm::None;
   using llvm::Optional;
   using llvm::OwningArrayRef;
   using llvm::SaveAndRestore;
   using llvm::SmallString;
   using llvm::SmallVector;
   using llvm::SmallVectorImpl;
   using llvm::StringRef;
   using llvm::Twine;
   using llvm::VersionTuple;
 
   // Error handling.
   using llvm::Expected;
 

clang/lib/CodeGen/CGStmtOpenMP.cpp

static EmittedClosureTy emitCapturedStmtFunc(CodeGenFunction &ParentCGF,
   return {F, CapStruct.getPointer(ParentCGF)};
 }
 
 /// Emit a call to a previously captured closure.
 static llvm::CallInst *
 emitCapturedStmtCall(CodeGenFunction &ParentCGF, EmittedClosureTy Cap,
                      llvm::ArrayRef<llvm::Value *> Args) {
   // Append the closure context to the argument.
-  llvm::SmallVector<llvm::Value *> EffectiveArgs;
+  SmallVector<llvm::Value *> EffectiveArgs;
   EffectiveArgs.reserve(Args.size() + 1);
   llvm::append_range(EffectiveArgs, Args);
   EffectiveArgs.push_back(Cap.second);
 
   return ParentCGF.Builder.CreateCall(Cap.first, EffectiveArgs);
 }
 
 llvm::CanonicalLoopInfo *

clang/lib/Frontend/CompilerInvocation.cpp

#endif
   llvm::StringSaver StringPool(Alloc);
   auto SA = [&StringPool](const Twine &Arg) {
     return StringPool.save(Arg).data();
   };
 
   // Generate arguments from the dummy invocation. If Generate is the
   // inverse of Parse, the newly generated arguments must have the same
   // semantics as the original.
-  SmallVector<const char *, 16> GeneratedArgs1;
+  SmallVector<const char *> GeneratedArgs1;
   Generate(DummyInvocation, GeneratedArgs1, SA);
 
   // Run the second parse, now on the generated arguments, and with the real
   // invocation and diagnostics. The result is what we will end up using for the
   // rest of compilation, so if Generate is not inverse of Parse, something down
   // the line will break.
   bool Success2 = Parse(RealInvocation, GeneratedArgs1, Diags, Argv0);
 
   // The first parse on original arguments succeeded, but second parse of
   // generated arguments failed. Something must be wrong with the generator.
   if (!Success2) {
     Diags.Report(diag::err_cc1_round_trip_ok_then_fail);
     Diags.Report(diag::note_cc1_round_trip_generated)
         << 1 << SerializeArgs(GeneratedArgs1);
     return false;
   }
 
   // Generate arguments again, this time from the options we will end up using
   // for the rest of the compilation.
-  SmallVector<const char *, 16> GeneratedArgs2;
+  SmallVector<const char *> GeneratedArgs2;
   Generate(RealInvocation, GeneratedArgs2, SA);
 
   // Compares two lists of generated arguments.
   auto Equal = [](const ArrayRef<const char *> A,
                   const ArrayRef<const char *> B) {
     return std::equal(A.begin(), A.end(), B.begin(), B.end(),
                       [](const char *AElem, const char *BElem) {
                         return StringRef(AElem) == StringRef(BElem);