[Clang] Fix some Clang-tidy modernize-use-using and Include What You Use warnings

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[compnerd]

include/clang/Basic/IdentifierTable.h

34

Not sure the whitespace adds any benefit here.

103

Isn't the LLVM style to prefer the negation? Why did the infix operators not get space around them?

include/clang/Frontend/ASTUnit.h

52

Not sure the whitespace is beneficial here.

928

This is weirdly formatted. I think its fine to clang-format this line.

include/clang/Lex/PreprocessorOptions.h

22

Don't think that the whitespace is beneficial here.

[Eugene.Zelenko]

Apply Clang-format.

[Eugene.Zelenko]

include/clang/Basic/IdentifierTable.h

103

memcpy result is three state, so applying Boolean operator is not correct.

include/clang/Lex/PreprocessorOptions.h

22

I wanted to make spacing consistent. Same in other places.

Actually, Include What You Use recommended to include MemoryBuffer.h. MemoryBuffer is used in smart pointers, but I remember that I encountered problems in LLDB MSVC builds, where forward declaration was not enough for such usage.

[mehdi_amini]

include/clang/Basic/IdentifierTable.h

103

What do you mean "applying Boolean operator is not correct"?
http://en.cppreference.com/w/cpp/language/implicit_conversion # Boolean conversions

The value zero (for integral, floating-point, and unscoped enumeration) and the null pointer and the null pointer-to-member values become false. All other values become true.

Seems good to me?

include/clang/Lex/PreprocessorOptions.h

22

I think in a recent review you mentioned "empty lines make code more readable for large namespaces", which does not seem to be the case here?

[Eugene.Zelenko]

include/clang/Basic/IdentifierTable.h

103

I think explicit operation is more comprehensible them implicit.

include/clang/Lex/PreprocessorOptions.h

22

I prefer spacing to be consistent.

include/clang/AST/RecursiveASTVisitor.h

 //  traverses the entire AST.
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
 #define LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
 
-#include <type_traits>
-
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
+#include "clang/AST/LambdaCapture.h"
 #include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"

 #include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/OpenMPKinds.h"
+#include "clang/Basic/Specifiers.h"
+#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include <algorithm>
+#include <cstddef>
+#include <type_traits>
 
 // The following three macros are used for meta programming.  The code
 // using them is responsible for defining macro OPERATOR().

   do {                                                                         \
     if (!getDerived().CALL_EXPR)                                               \
       return false;                                                            \
-  } while (0)
+  } while (false)
 
 /// \brief A class that does preordor or postorder
 /// depth-first traversal on the entire Clang AST and visits each node.

   do {                                                                         \
     if (!TRAVERSE_STMT_BASE(Stmt, Stmt, S, Queue))                             \
       return false;                                                            \
-  } while (0)
+  } while (false)
 
 public:
 // Declare Traverse*() for all concrete Stmt classes.

 
 #undef DISPATCH_STMT
 
-
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
   switch (S->getStmtClass()) {

   case DeclarationName::CXXConversionFunctionName:
     if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
       TRY_TO(TraverseTypeLoc(TSInfo->getTypeLoc()));
-
     break;
 
   case DeclarationName::Identifier:

 DEF_TRAVERSE_STMT(ObjCAtTryStmt, {})
 DEF_TRAVERSE_STMT(ObjCForCollectionStmt, {})
 DEF_TRAVERSE_STMT(ObjCAutoreleasePoolStmt, {})
+
 DEF_TRAVERSE_STMT(CXXForRangeStmt, {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getLoopVarStmt());

     ShouldVisitChildren = false;
   }
 })
+
 DEF_TRAVERSE_STMT(MSDependentExistsStmt, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
 })
+
 DEF_TRAVERSE_STMT(ReturnStmt, {})
 DEF_TRAVERSE_STMT(SwitchStmt, {})
 DEF_TRAVERSE_STMT(WhileStmt, {})

 DEF_TRAVERSE_STMT(AddrLabelExpr, {})
 DEF_TRAVERSE_STMT(ArraySubscriptExpr, {})
 DEF_TRAVERSE_STMT(OMPArraySectionExpr, {})
+
 DEF_TRAVERSE_STMT(BlockExpr, {
   TRY_TO(TraverseDecl(S->getBlockDecl()));
   return true; // no child statements to loop through.
 })
+
 DEF_TRAVERSE_STMT(ChooseExpr, {})
+
 DEF_TRAVERSE_STMT(CompoundLiteralExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })
+
 DEF_TRAVERSE_STMT(CXXBindTemporaryExpr, {})
 DEF_TRAVERSE_STMT(CXXBoolLiteralExpr, {})
 DEF_TRAVERSE_STMT(CXXDefaultArgExpr, {})

 DEF_TRAVERSE_STMT(CXXInheritedCtorInitExpr, {})
 DEF_TRAVERSE_STMT(CXXNullPtrLiteralExpr, {})
 DEF_TRAVERSE_STMT(CXXStdInitializerListExpr, {})
+
 DEF_TRAVERSE_STMT(CXXPseudoDestructorExpr, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())

   if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo())
     TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc()));
 })
+
 DEF_TRAVERSE_STMT(CXXThisExpr, {})
 DEF_TRAVERSE_STMT(CXXThrowExpr, {})
 DEF_TRAVERSE_STMT(UserDefinedLiteral, {})

 DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {})
 DEF_TRAVERSE_STMT(NoInitExpr, {})
 DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {})
+
 DEF_TRAVERSE_STMT(ObjCEncodeExpr, {
   if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo())
     TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
 })
+
 DEF_TRAVERSE_STMT(ObjCIsaExpr, {})
 DEF_TRAVERSE_STMT(ObjCIvarRefExpr, {})
+
 DEF_TRAVERSE_STMT(ObjCMessageExpr, {
   if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo())
     TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
 })
+
 DEF_TRAVERSE_STMT(ObjCPropertyRefExpr, {})
 DEF_TRAVERSE_STMT(ObjCSubscriptRefExpr, {})
 DEF_TRAVERSE_STMT(ObjCProtocolExpr, {})
 DEF_TRAVERSE_STMT(ObjCSelectorExpr, {})
 DEF_TRAVERSE_STMT(ObjCIndirectCopyRestoreExpr, {})
+
 DEF_TRAVERSE_STMT(ObjCBridgedCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
+
 DEF_TRAVERSE_STMT(ObjCAvailabilityCheckExpr, {})
 DEF_TRAVERSE_STMT(ParenExpr, {})
 DEF_TRAVERSE_STMT(ParenListExpr, {})

 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
 DEF_TRAVERSE_STMT(StmtExpr, {})
+
 DEF_TRAVERSE_STMT(UnresolvedLookupExpr, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   if (S->hasExplicitTemplateArgs()) {

     ShouldVisitChildren = false;
   }
 })
+
 DEF_TRAVERSE_STMT(CoreturnStmt, {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
     ShouldVisitChildren = false;
   }
 })
+
 DEF_TRAVERSE_STMT(CoawaitExpr, {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
     ShouldVisitChildren = false;
   }
 })
+
 DEF_TRAVERSE_STMT(CoyieldExpr, {
   if (!getDerived().shouldVisitImplicitCode()) {
     TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());

include/clang/Basic/IdentifierTable.h

 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/TokenKinds.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Allocator.h"
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <new>
 #include <string>
+#include <utility>
 
 namespace llvm {
+
   template <typename T> struct DenseMapInfo;
-}
 
+} // end namespace llvm
+
 namespace clang {
+
   class LangOptions;
   class IdentifierInfo;
   class IdentifierTable;

   /// \brief A simple pair of identifier info and location.
   typedef std::pair<IdentifierInfo*, SourceLocation> IdentifierLocPair;
 
-
 /// One of these records is kept for each identifier that
 /// is lexed.  This contains information about whether the token was \#define'd,
 /// is a language keyword, or if it is a front-end token of some sort (e.g. a

 public:
   IdentifierInfo();
 
-
   /// \brief Return true if this is the identifier for the specified string.
   ///
   /// This is intended to be used for string literals only: II->isStr("foo").
   template <std::size_t StrLen>
   bool isStr(const char (&Str)[StrLen]) const {
-    return getLength() == StrLen-1 && !memcmp(getNameStart(), Str, StrLen-1);
+    return getLength() == StrLen-1 &&
+           memcmp(getNameStart(), Str, StrLen-1) == 0;
   }
 
   /// \brief Return the beginning of the actual null-terminated string for this

 
     HasMacro = Val;
     if (Val) {
-      NeedsHandleIdentifier = 1;
+      NeedsHandleIdentifier = true;
       HadMacro = true;
     } else {
       RecomputeNeedsHandleIdentifier();

   void setIsExtensionToken(bool Val) {
     IsExtension = Val;
     if (Val)
-      NeedsHandleIdentifier = 1;
+      NeedsHandleIdentifier = true;
     else
       RecomputeNeedsHandleIdentifier();
   }

   void setIsFutureCompatKeyword(bool Val) {
     IsFutureCompatKeyword = Val;
     if (Val)
-      NeedsHandleIdentifier = 1;
+      NeedsHandleIdentifier = true;
     else
       RecomputeNeedsHandleIdentifier();
   }

   void setIsPoisoned(bool Value = true) {
     IsPoisoned = Value;
     if (Value)
-      NeedsHandleIdentifier = 1;
+      NeedsHandleIdentifier = true;
     else
       RecomputeNeedsHandleIdentifier();
   }

   void setIsCPlusPlusOperatorKeyword(bool Val = true) {
     IsCPPOperatorKeyword = Val;
     if (Val)
-      NeedsHandleIdentifier = 1;
+      NeedsHandleIdentifier = true;
     else
       RecomputeNeedsHandleIdentifier();
   }

 class PoisonIdentifierRAIIObject {
   IdentifierInfo *const II;
   const bool OldValue;
+
 public:
   PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue)
     : II(II), OldValue(II ? II->isPoisoned() : false) {

 
   iterator begin() const { return HashTable.begin(); }
   iterator end() const   { return HashTable.end(); }
-  unsigned size() const { return HashTable.size(); }
+  unsigned size() const  { return HashTable.size(); }
 
   /// \brief Print some statistics to stderr that indicate how well the
   /// hashing is doing.

       return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags);
     return nullptr;
   }
+
   MultiKeywordSelector *getMultiKeywordSelector() const {
     return reinterpret_cast<MultiKeywordSelector *>(InfoPtr & ~ArgFlags);
   }

   bool operator!=(Selector RHS) const {
     return InfoPtr != RHS.InfoPtr;
   }
+
   void *getAsOpaquePtr() const {
     return reinterpret_cast<void*>(InfoPtr);
   }

   bool isKeywordSelector() const {
     return getIdentifierInfoFlag() != ZeroArg;
   }
+
   bool isUnarySelector() const {
     return getIdentifierInfoFlag() == ZeroArg;
   }
+
   unsigned getNumArgs() const;
   
-  
   /// \brief Retrieve the identifier at a given position in the selector.
   ///
   /// Note that the identifier pointer returned may be NULL. Clients that only

   static Selector getEmptyMarker() {
     return Selector(uintptr_t(-1));
   }
+
   static Selector getTombstoneMarker() {
     return Selector(uintptr_t(-2));
   }

   void *Impl;  // Actually a SelectorTableImpl
   SelectorTable(const SelectorTable &) = delete;
   void operator=(const SelectorTable &) = delete;
+
 public:
   SelectorTable();
   ~SelectorTable();

 }  // end namespace clang
 
 namespace llvm {
+
 /// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and
 /// DenseSets.
 template <>

   static inline clang::Selector getEmptyKey() {
     return clang::Selector::getEmptyMarker();
   }
+
   static inline clang::Selector getTombstoneKey() {
     return clang::Selector::getTombstoneMarker();
   }

   static inline const void *getAsVoidPointer(clang::Selector P) {
     return P.getAsOpaquePtr();
   }
+
   static inline clang::Selector getFromVoidPointer(const void *P) {
     return clang::Selector(reinterpret_cast<uintptr_t>(P));
   }
+
   enum { NumLowBitsAvailable = 0 };  
 };
 

   static inline void *getAsVoidPointer(clang::IdentifierInfo* P) {
     return P;
   }
+
   static inline clang::IdentifierInfo *getFromVoidPointer(void *P) {
     return static_cast<clang::IdentifierInfo*>(P);
   }
+
   enum { NumLowBitsAvailable = 1 };
 };
 

   static inline const void *getAsVoidPointer(const clang::IdentifierInfo* P) {
     return P;
   }
+
   static inline const clang::IdentifierInfo *getFromVoidPointer(const void *P) {
     return static_cast<const clang::IdentifierInfo*>(P);
   }
+
   enum { NumLowBitsAvailable = 1 };
 };
 
-}  // end namespace llvm
-#endif
+} // end namespace llvm
+
+#endif // LLVM_CLANG_BASIC_IDENTIFIERTABLE_H

include/clang/Frontend/ASTUnit.h

 
 #include "clang-c/Index.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/Module.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetOptions.h"
 #include "clang/Lex/HeaderSearchOptions.h"

 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Serialization/ASTBitCodes.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MD5.h"
+#include <algorithm>
 #include <cassert>
+#include <cstdint>
+#include <cstddef>
 #include <memory>
 #include <string>
 #include <sys/types.h>

 #include <vector>
 
 namespace llvm {
+
   class MemoryBuffer;
-}
 
+} // end namespace llvm
+
 namespace clang {
+
 class Sema;
 class ASTContext;
 class ASTReader;

       unsigned PrecompilePreambleAfterNParses);
 
 public:
-  
   /// \brief Create an ASTUnit from a source file, via a CompilerInvocation
   /// object, by invoking the optionally provided ASTFrontendAction. 
   ///

   void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility,
                          SourceLocation ImportLoc) override {}
 
-  GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override
-    { return nullptr; }
-  bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
-    { return 0; }
+  GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override {
+    return nullptr;
+  }
+
+  bool lookupMissingImports(StringRef Name,
+                            SourceLocation TriggerLoc) override {
+    return false;
+  }
 };
 
-} // namespace clang
+} // end namespace clang
 
-#endif
+#endif // LLVM_CLANG_FRONTEND_ASTUNIT_H

include/clang/Lex/PreprocessorOptions.h

 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
-#define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
+#ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H
+#define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H
 
-#include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
-#include <cassert>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
+
   class MemoryBuffer;
-}
 
+} // end namespace llvm
+
 namespace clang {
 
-class Preprocessor;
-class LangOptions;
-
 /// \brief Enumerate the kinds of standard library that 
 enum ObjCXXARCStandardLibraryKind {
   ARCXX_nolib,

     TokenCache.clear();
     RetainRemappedFileBuffers = true;
     PrecompiledPreambleBytes.first = 0;
-    PrecompiledPreambleBytes.second = 0;
+    PrecompiledPreambleBytes.second = false;
   }
 };
 
 } // end namespace clang
 
-#endif
+#endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H

include/clang/Sema/CodeCompleteConsumer.h

 //  This file defines the CodeCompleteConsumer class.
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
 #define LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
 
 #include "clang-c/Index.h"
 #include "clang/AST/CanonicalType.h"
+#include "clang/AST/DeclarationName.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/Type.h"
 #include "clang/Sema/CodeCompleteOptions.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
+#include <algorithm>
+#include <cassert>
 #include <string>
-#include <utility>
 
 namespace clang {
 

   bool wantConstructorResults() const;
 };
 
-
 /// \brief A "string" used to describe how code completion can
 /// be performed for an entity.
 ///

   : public CodeCompletionAllocator,
     public RefCountedBase<GlobalCodeCompletionAllocator>
 {
-
 };
 
 class CodeCompletionTUInfo {

 } // end namespace clang
 
 namespace llvm {
+
   template <> struct isPodLike<clang::CodeCompletionString::Chunk> {
     static const bool value = true;
   };
-}
 
+} // end namespace llvm
+
 namespace clang {
 
 /// \brief A builder class used to construct new code-completion strings.

     : Declaration(nullptr), Keyword(Keyword), Priority(Priority),
       StartParameter(0), Kind(RK_Keyword), CursorKind(CXCursor_NotImplemented),
       Availability(CXAvailability_Available), Hidden(false),
-      QualifierIsInformative(0), StartsNestedNameSpecifier(false),
+      QualifierIsInformative(false), StartsNestedNameSpecifier(false),
       AllParametersAreInformative(false), DeclaringEntity(false),
       Qualifier(nullptr) {}
 

     : Declaration(nullptr), Macro(Macro), Priority(Priority), StartParameter(0),
       Kind(RK_Macro), CursorKind(CXCursor_MacroDefinition),
       Availability(CXAvailability_Available), Hidden(false),
-      QualifierIsInformative(0), StartsNestedNameSpecifier(false),
+      QualifierIsInformative(false), StartsNestedNameSpecifier(false),
       AllParametersAreInformative(false), DeclaringEntity(false),
       Qualifier(nullptr) {}
 

                        const NamedDecl *D = nullptr)
     : Declaration(D), Pattern(Pattern), Priority(Priority), StartParameter(0),
       Kind(RK_Pattern), CursorKind(CursorKind), Availability(Availability),
-      Hidden(false), QualifierIsInformative(0),
+      Hidden(false), QualifierIsInformative(false),
       StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
       DeclaringEntity(false), Qualifier(nullptr)
   {

   return !(X < Y);
 }
 
-
 raw_ostream &operator<<(raw_ostream &OS,
-                              const CodeCompletionString &CCS);
 
 /// \brief Abstract interface for a consumer of code-completion
 /// information.

include/clang/Sema/Scope.h

 
 #include "clang/AST/Decl.h"
 #include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include <cassert>
 
 namespace llvm {
 
 class raw_ostream;
 
-}
+} // end namespace llvm
 
 namespace clang {
 

     /// We are currently in the filter expression of an SEH except block.
     SEHFilterScope = 0x200000,
   };
+
 private:
   /// The parent scope for this scope.  This is null for the translation-unit
   /// scope.

   Scope *getContinueParent() {
     return ContinueParent;
   }
-
   const Scope *getContinueParent() const {
     return const_cast<Scope*>(this)->getContinueParent();
   }

     }
     return false;
   }
-
   
   /// isTemplateParamScope - Return true if this scope is a C++
   /// template parameter scope.

   }
 
   void setNoNRVO() {
-    NRVO.setInt(1);
+    NRVO.setInt(true);
     NRVO.setPointer(nullptr);
   }
 

   void dump() const;
 };
 
-}  // end namespace clang
+} // end namespace clang
 
-#endif
+#endif // LLVM_CLANG_SEMA_SCOPE_H