[llvm, clang] Remove stdlib includes from .h files without `std::`

[thakis]

Summary

Found files not containing std:: with:

INCL="algorithm|array|list|map|memory|queue|set|string|utility|vector|unordered_map|unordered_set"
git ls-files llvm/include/llvm | grep '\.h$' | xargs grep -L std:: | \
    xargs grep -El "#include <($INCL)>$" > to_process.txt
git ls-files clang/include/clang | grep '\.h$' | xargs grep -L std:: | \
    xargs grep -El "#include <($INCL)>$" >> to_process.txt

Then removed these headers from those files with

INCL_ESCAPED="$(echo $INCL|sed 's/|/\\|/g')"
cat to_process.txt | xargs sed -i "/^#include <\($INCL_ESCAPED\)>$/d"
cat to_process.txt | xargs sed -i '/^$/N;/^\n$/D'

No behavior change.

[aeubanks]

lgtm

[amccarth]

A drive-by look.

clang/include/clang/Tooling/Transformer/Parsing.h

24

<functional> appears unnecessary as well.

And while this doesn't require <string> it does require llvm/ADT/StringRef.h.

llvm/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h

72

size_t may have been coming indirectly from <memory>.

clang/include/clang/AST/DeclContextInternals.h

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclarationName.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/PointerUnion.h"
-#include <algorithm>
 #include <cassert>
 
 namespace clang {
 
 class DependentDiagnostic;
 
 /// An array of decls optimized for the common case of only containing
 /// one entry.

clang/include/clang/Driver/Options.h

 //===--- Options.h - Option info & table ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_DRIVER_OPTIONS_H
 #define LLVM_CLANG_DRIVER_OPTIONS_H
 
-#include <memory>
-
 namespace llvm {
 namespace opt {
 class OptTable;
 }
 }
 
 namespace clang {
 namespace driver {

clang/include/clang/Index/CommentToXML.h

 //===--- CommentToXML.h - Convert comments to XML representation ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_INDEX_COMMENTTOXML_H
 #define LLVM_CLANG_INDEX_COMMENTTOXML_H
 
 #include "clang/Basic/LLVM.h"
-#include <memory>
 
 namespace clang {
 class ASTContext;
 
 namespace comments {
 class FullComment;
 class HTMLTagComment;
 }

clang/include/clang/StaticAnalyzer/Core/PathSensitive/DynamicType.h

 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicCastInfo.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeInfo.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramState_Fwd.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/Optional.h"
-#include <utility>
 
 namespace clang {
 namespace ento {
 
 /// Get dynamic type information for the region \p MR.
 DynamicTypeInfo getDynamicTypeInfo(ProgramStateRef State, const MemRegion *MR);
 
 /// Get raw dynamic type information for the region \p MR.

clang/include/clang/Tooling/Refactoring/RefactoringActionRule.h

 //===--- RefactoringActionRule.h - Clang refactoring library -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H
 #define LLVM_CLANG_TOOLING_REFACTOR_REFACTORING_ACTION_RULE_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
-#include <vector>
 
 namespace clang {
 namespace tooling {
 
 class RefactoringOptionVisitor;
 class RefactoringResultConsumer;
 class RefactoringRuleContext;
 

clang/include/clang/Tooling/Transformer/Parsing.h

 #ifndef LLVM_CLANG_TOOLING_REFACTOR_PARSING_H_
 #define LLVM_CLANG_TOOLING_REFACTOR_PARSING_H_
 
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Tooling/Transformer/RangeSelector.h"
 #include "llvm/Support/Error.h"
 #include <functional>
-#include <string>
 
 namespace clang {
 namespace transformer {
 
 /// Parses a string representation of a \c RangeSelector. The grammar of these
 /// strings is closely based on the (sub)grammar of \c RangeSelectors as they'd
 /// appear in C++ code. However, this language constrains the set of permissible
 /// strings (for node ids) -- it does not support escapes in the

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

 #include "llvm/CodeGen/MachineInstrBundle.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstdint>
-#include <utility>
 
 namespace llvm {
 
 class MCInstrDesc;
 class MDNode;
 
 namespace RegState {
 

llvm/include/llvm/CodeGen/TileShapeInfo.h

 #ifndef LLVM_CODEGEN_TILESHAPEINFO_H
 #define LLVM_CODEGEN_TILESHAPEINFO_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/Register.h"
-#include <utility>
 
 namespace llvm {
 
 class ShapeT {
 public:
   ShapeT(MachineOperand *Row, MachineOperand *Col,
          const MachineRegisterInfo *MRI = nullptr)
       : Row(Row), Col(Col) {

llvm/include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Allocator.h"
 #include <cstdint>
-#include <memory>
 
 namespace llvm {
 namespace codeview {
 
 class ContinuationRecordBuilder;
 
 class AppendingTypeTableBuilder : public TypeCollection {
 

llvm/include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h

 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Allocator.h"
 #include <cassert>
 #include <cstdint>
-#include <memory>
 
 namespace llvm {
 namespace codeview {
 
 class ContinuationRecordBuilder;
 
 class GlobalTypeTableBuilder : public TypeCollection {
   /// Storage for records.  These need to outlive the TypeTableBuilder.
public:
   TypeIndex nextTypeIndex() const;
 
   BumpPtrAllocator &getAllocator() { return RecordStorage; }
 
   ArrayRef<ArrayRef<uint8_t>> records() const;
   ArrayRef<GloballyHashedType> hashes() const;
 
   template <typename CreateFunc>
   TypeIndex insertRecordAs(GloballyHashedType Hash, size_t RecordSize,
                            CreateFunc Create) {
     assert(RecordSize < UINT32_MAX && "Record too big");
     assert(RecordSize % 4 == 0 &&
            "RecordSize is not a multiple of 4 bytes which will cause "
            "misalignment in the output TPI stream!");
 
     auto Result = HashedRecords.try_emplace(Hash, nextTypeIndex());
 

llvm/include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/SimpleTypeSerializer.h"
 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/Support/Allocator.h"
 #include <cstdint>
-#include <memory>
 
 namespace llvm {
 namespace codeview {
 
 class ContinuationRecordBuilder;
 
 class MergingTypeTableBuilder : public TypeCollection {
   /// Storage for records.  These need to outlive the TypeTableBuilder.

llvm/include/llvm/DebugInfo/GSYM/FileEntry.h

 //===- FileEntry.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_FILEENTRY_H
 #define LLVM_DEBUGINFO_GSYM_FILEENTRY_H
 
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include <functional>
 #include <stdint.h>
-#include <utility>
 
 namespace llvm {
 namespace gsym {
 
 /// Files in GSYM are contained in FileEntry structs where we split the
 /// directory and basename into two different strings in the string
 /// table. This allows paths to shared commont directory and filename
 /// strings and saves space.

llvm/include/llvm/DebugInfo/GSYM/StringTable.h

 //===- StringTable.h --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_STRINGTABLE_H
 #define LLVM_DEBUGINFO_GSYM_STRINGTABLE_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/GSYM/Range.h"
 #include <stdint.h>
-#include <string>
-
 
 namespace llvm {
 namespace gsym {
 
 /// String tables in GSYM files are required to start with an empty
 /// string at offset zero. Strings must be UTF8 NULL terminated strings.
 struct StringTable {
   StringRef Data;

llvm/include/llvm/ExecutionEngine/Orc/OrcABISupport.h

 
 #ifndef LLVM_EXECUTIONENGINE_ORC_ORCABISUPPORT_H
 #define LLVM_EXECUTIONENGINE_ORC_ORCABISUPPORT_H
 
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
-#include <algorithm>
 #include <cstdint>
 
 namespace llvm {
 namespace orc {
 
 struct IndirectStubsAllocationSizes {
   uint64_t StubBytes = 0;
   uint64_t PointerBytes = 0;

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
 #define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
 
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/Support/Error.h"
-#include <vector>
 
 namespace llvm {
 namespace orc {
 
 /// Register frames in the given eh-frame section with libunwind.
 Error registerEHFrameSection(const void *EHFrameSectionAddr,
                              size_t EHFrameSectionSize);
 

llvm/include/llvm/Target/CGPassBuilderOption.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_CGPASSBUILDEROPTION_H
 #define LLVM_TARGET_CGPASSBUILDEROPTION_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Target/TargetOptions.h"
-#include <vector>
 
 namespace llvm {
 class TargetMachine;
 
 enum class RunOutliner { TargetDefault, AlwaysOutline, NeverOutline };
 enum class RegAllocType { Default, Basic, Fast, Greedy, PBQP };
 enum class CFLAAType { None, Steensgaard, Andersen, Both };
 

llvm/include/llvm/Transforms/Scalar/SpeculateAroundPHIs.h

 #define LLVM_TRANSFORMS_SCALAR_SPECULATEAROUNDPHIS_H
 
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/Compiler.h"
-#include <vector>
 
 namespace llvm {
 
 /// This pass handles simple speculating of  instructions around PHIs when
 /// doing so is profitable for a particular target despite duplicated
 /// instructions.
 ///
 /// The motivating example are PHIs of constants which will require