Changes in clang after running http://reviews.llvm.org/D18821

[Prazek]

Summary

I am not done with analysis, and I don't want to push it to repo as it is, because in many cases when programmer wrote true/false he wanted to have bool instead of int.

Some nice example:
unsigned IsFilled : 1;

/// Simplified kind of \c CommentDecl, see \c DeclKind enum.
unsigned Kind : 3;

/// Is \c CommentDecl a template declaration.
unsigned TemplateKind : 2;

/// Is \c CommentDecl an ObjCMethodDecl.
unsigned IsObjCMethod : 1;

/// Is \c CommentDecl a non-static member function of C++ class or
/// instance method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsInstanceMethod : 1;

/// Is \c CommentDecl a static member function of C++ class or
/// class method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsClassMethod : 1;

I want to replace all unsigned that are 1 bits with bool.

[thakis]

I want to replace all unsigned that are 1 bits with bool.

MSVC only packs bitfields of the same type together, so doing that change would make clang use much more memory on Windows.

[Prazek]

In D19105#400966, @thakis wrote:

I want to replace all unsigned that are 1 bits with bool.

MSVC only packs bitfields of the same type together, so doing that change would make clang use much more memory on Windows.

Seriously MSVC? Seriously?
I guess I will have add something to my check to ignore bitfields of 1.

[alexfh]

Ignoring 1-bit wide bitfields seems like a reasonable thing to do for the check. Most of the changes I see here are making the code less idiomatic, I'd say.

[Prazek]

It seems that is doing it's work right now.

I will have to change some places to post it to llvm like:

• changing functions return type to bool
• removng comparasion with bool for bools

[• Quuxplusone]

It seems like this proposed diagnostic and fixit, statistically speaking, is *never* correct.
In the cases where there is a code issue to be corrected, the diagnosable issue really seems to involve dataflow analysis:

"Here is a variable of integral type (not bool), which over its lifetime assumes only the values 0 and 1. This variable should be declared as type bool."
"Here is a function returning integral type (not bool), which returns only the values 0 and 1. This function should be declared as returning type bool."
"Here is a parameter of integral type (not bool), which (via whole-program analysis) assumes only the values 0 and 1. This parameter should be declared as type bool."

lib/AST/DeclPrinter.cpp

1016

This is clearly the wrong correction, don't you think? Should be s/unsigned/bool/, not s/true/1/.

lib/AST/DeclarationName.cpp

104

This seems like it might be a real bug: somebody in the past cut-and-pasting the implementation of operator<() into this compare() function. I suspect (but please don't trust me) that the proper fix is s/true/-1/ s/false/1/.

lib/Bitcode/Writer/BitWriter.cpp

40 ↗

(On Diff #56250)

This also seems like the wrong correction.

lib/Bitcode/Writer/BitcodeWriter.cpp

1332 ↗

(On Diff #56250)

This seems like a "correct" but unwanted adjustment. *Maybe* there's a case for static_cast<uint64_t>(true)... but personally I'd leave the true alone.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

593 ↗

(On Diff #56250)

Here is the first clearly beneficial correction I've noticed.

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

1562 ↗

(On Diff #56250)

If I understand correctly, the idiomatic C++11 way to write this code would be

static constexpr bool IsBottomUp = true;
static constexpr bool HasReadyFilter = false;

I think the proposed correction is worse than the original, because it makes this look like an integer enumeration.

lib/Driver/Tools.cpp

2022

Shouldn't the original code already have triggered some warning about explicit comparison with a boolean value?

if (OptionIter->second) {

doesn't have literally the same semantics, but it's clearly IMHO what was intended.
Also, if decltype(llvm::StringMap<bool>::iterator{}->second) is not bool, something weird is going on.

lib/IR/Core.cpp

227 ↗

(On Diff #56250)

This correction is wrong; either true should be accepted as a valid value for LLVMBool, or LLVMBool should be replaced with bool.

[jfb]

lib/Transforms/IPO/MergeFunctions.cpp

147 ↗

(On Diff #56250)

This change should go to ValueMap, I think it should be moved to an enum class, and all uses of ValueMap should be changed accordingly. This is meant to act as a bool IMO, it's odd to make it otherwise.

[Prazek]

In D19105#422702, @Quuxplusone wrote:

It seems like this proposed diagnostic and fixit, statistically speaking, is *never* correct.
In the cases where there is a code issue to be corrected, the diagnosable issue really seems to involve dataflow analysis:

"Here is a variable of integral type (not bool), which over its lifetime assumes only the values 0 and 1. This variable should be declared as type bool."
"Here is a function returning integral type (not bool), which returns only the values 0 and 1. This function should be declared as returning type bool."
"Here is a parameter of integral type (not bool), which (via whole-program analysis) assumes only the values 0 and 1. This parameter should be declared as type bool."

You are right, if someone is using true/false, then he probably mean it, and he is just assigning it to wrong type. But I don't see a point spending too much time to write something that would be smart enough to fix most of the issues as we would like. I think having this fixit is good for now and I would leave it like this.
From my usage, I like when clang-tidy touch some files and changes it somewhow, so it is much simpler to check it in git than to look at the warnings.

lib/Driver/Tools.cpp

2022

te misc-simplify-boolean-expression is to solve this problem. I will check if this code make sense.

[alexfh]

Too much noise here as well. Particularly, someBool == true should not be changed to someBool == 1. Please fix the check and update the results.

clang-tidy/readability/ImplicitBoolCastCheck.cpp

253 ↗

(On Diff #56250)

Seems like a bug. CXXBoolLiteralExpr::getValue() returns bool.

lib/AsmParser/LLParser.cpp

4868 ↗

(On Diff #56250)

Looks like this should return InstResult and the return values should be replaced by proper enumerators.

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

1562 ↗

(On Diff #56250)

I agree that changing this to integers is a regression. However, we can't yet use constexpr, since VS2013 doesn't support it. Looks like this file just needs to be reverted.

lib/IR/Core.cpp

227 ↗

(On Diff #56250)

This function is a part of C API, so we can't use bool here, and LLVMBool is the right choice. However, it might make sense to add LLVM_TRUE and LLVM_FALSE constants/macros to include/llvm-c/Types.h to more clearly specify possible values for the LLVMBool type.

lib/Lex/PPMacroExpansion.cpp

1689

This actually seems like a useful replacement ;)

lib/MC/MCContext.cpp

314 ↗

(On Diff #56250)

That one is interesting: passing true (or 1) to unsigned UniqueID seems like a very weird thing to do. Please at least add a /*UniqueID=*/ comment before the argument to make this weirdness more explicit.

lib/Sema/SemaOpenMP.cpp

4487

Instead, the parameter type should be changed to bool.

lib/Serialization/ASTReader.cpp

5453

That's wrong. Instead, Record[Idx++] should be changed to Record[Idx++] != 0.

lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

194 ↗

(On Diff #56250)

This is wrong.

[alexfh]

The bottom line is that the fixit in its current form is not particularly useful in most cases. We should try to detect some cases where the replacement is unlikely to be useful, e.g. the enum { FollowRAUW = false }; pattern, returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

[Prazek]

In D19105#426903, @alexfh wrote:

returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

Isn't it LLVMBool issue?

I won't have enough time to fix it, so I would prefer to comment fixit and only push warnings.

[Prazek]

lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

194 ↗

(On Diff #56250)

Of course it is, but the prevoius code was also creepy :P

[alexfh]

In D19105#427046, @Prazek wrote:

In D19105#426903, @alexfh wrote:

returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

Isn't it LLVMBool issue?

I won't have enough time to fix it, so I would prefer to comment fixit and only push warnings.

Whether we disable fixits or not, there seem to be too many false positives for the check to be useful. We should fix at least cases like bool b; ... if (b == true) ... and bool b; ... b ^= true;.

[Prazek]

Fixed many stuff.

Note that I won't push this patch mainly because of LLVMBool stuff and some other small issues. I don't think there can be done anything more for this check.

[deadalnix]

include/llvm-c/Core.h

604 ↗

(On Diff #58313)

Please keep LLVMBool in the C API. ABI change are a NO NO.

[Prazek]

include/llvm-c/Core.h

604 ↗

(On Diff #58313)

As I said in my comment, I won't commit most of the changes. This review is only to show what check has found.

[alexfh]

Most of the fixits are still useless, but I didn't notice any false positives (i.e. all warnings would be useful to some degree). So I suggest disabling the fixes completely at least for now.

include/llvm-c/Core.h

604 ↗

(On Diff #58313)

From what I see in this patch, changing the function type to bool not a useful fix, and certainly a dangerous one, since 1. ABI changes, 2. The check can't see all the users of the function.

lib/AST/Decl.cpp

173

Apparently, the check should filter out template instantiations.

lib/CodeGen/CGOpenMPRuntime.cpp

1934

Looks like the parameter type should be changed to bool instead.

lib/CodeGen/SplitKit.h

298 ↗

(On Diff #58313)

Is it an automated fix?

lib/Target/ARM/ARMConstantIslandPass.cpp

1643 ↗

(On Diff #58313)

In this case, changing the type would be better.

utils/TableGen/CTagsEmitter.cpp

36 ↗

(On Diff #58313)

One of the few cases where changing the function return type makes sense.

[Prazek]

lib/CodeGen/SplitKit.h

298 ↗

(On Diff #58313)

No, this is the only one that I'have made by hand, so it won't change some calls on this type

lib/ARCMigrate/ARCMT.cpp

if (!OriginalFile.empty())
       PPOpts.Includes.insert(PPOpts.Includes.begin(), OriginalFile);
     PPOpts.ImplicitPCHInclude.clear();
   }
   // FIXME: Get the original header of a PTH as well.
   CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear();
   std::string define = getARCMTMacroName();
   define += '=';
   CInvok->getPreprocessorOpts().addMacroDef(define);
-  CInvok->getLangOpts()->ObjCAutoRefCount = true;
+  CInvok->getLangOpts()->ObjCAutoRefCount = 1;
   CInvok->getLangOpts()->setGC(LangOptions::NonGC);
   CInvok->getDiagnosticOpts().ErrorLimit = 0;
   CInvok->getDiagnosticOpts().PedanticErrors = 0;
 
   // Ignore -Werror flags when migrating.
   std::vector<std::string> WarnOpts;
   for (std::vector<std::string>::iterator
          I = CInvok->getDiagnosticOpts().Warnings.begin(),
applyTransforms(CompilerInvocation &origCI, const FrontendInputFile &Input,
   }
 
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
       new DiagnosticsEngine(DiagID, &origCI.getDiagnosticOpts(),
                             DiagClient, /*ShouldOwnClient=*/false));
 
   if (outputDir.empty()) {
-    origCI.getLangOpts()->ObjCAutoRefCount = true;
+    origCI.getLangOpts()->ObjCAutoRefCount = 1;
     return migration.getRemapper().overwriteOriginal(*Diags);
   } else {
     return migration.getRemapper().flushToDisk(outputDir, *Diags);
   }
 }
 
 bool arcmt::applyTransformations(
     CompilerInvocation &origCI, const FrontendInputFile &Input,
MigrationProcess::MigrationProcess(
   }
 }
 
 bool MigrationProcess::applyTransform(TransformFn trans,
                                       RewriteListener *listener) {
   std::unique_ptr<CompilerInvocation> CInvok;
   CInvok.reset(
       createInvocationForMigration(OrigCI, PCHContainerOps->getRawReader()));
-  CInvok->getDiagnosticOpts().IgnoreWarnings = true;
+  CInvok->getDiagnosticOpts().IgnoreWarnings = 1;
 
   Remapper.applyMappings(CInvok->getPreprocessorOpts());
 
   CapturedDiagList capturedDiags;
   std::vector<SourceLocation> ARCMTMacroLocs;
 
   assert(DiagClient);
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());

lib/ARCMigrate/ObjCMT.cpp

if (!isa<TypedefType>(RT)) {
     if (CanResultTy.getQualifiers().hasObjCLifetime()) {
       Qualifiers Qs = CanResultTy.getQualifiers();
       Qs.removeObjCLifetime();
       RT = Context.getQualifiedType(CanResultTy.getUnqualifiedType(), Qs);
     }
   }
   PropertyString += " ";
   PrintingPolicy SubPolicy(Context.getPrintingPolicy());
-  SubPolicy.SuppressStrongLifetime = true;
-  SubPolicy.SuppressLifetimeQualifiers = true;
+  SubPolicy.SuppressStrongLifetime = 1;
+  SubPolicy.SuppressLifetimeQualifiers = 1;
   std::string TypeString = RT.getAsString(SubPolicy);
   if (LengthOfPrefix > 0) {
     // property name must strip off "is" and lower case the first character
     // after that; e.g. isContinuous will become continuous.
     StringRef PropertyNameStringRef(PropertyNameString);
     PropertyNameStringRef = PropertyNameStringRef.drop_front(LengthOfPrefix);
     PropertyNameString = PropertyNameStringRef;
     bool NoLowering = (isUppercase(PropertyNameString[0]) &&

lib/AST/ASTContext.cpp

if (const ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(DC)) {
     }
   }
 }
 
 comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
                                                     const Decl *D) const {
   comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo;
   ThisDeclInfo->CommentDecl = D;
-  ThisDeclInfo->IsFilled = false;
+  ThisDeclInfo->IsFilled = 0;
   ThisDeclInfo->fill();
   ThisDeclInfo->CommentDecl = FC->getDecl();
   if (!ThisDeclInfo->TemplateParameters)
     ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
   comments::FullComment *CFC =
     new (*this) comments::FullComment(FC->getBlocks(),
                                       ThisDeclInfo);
   return CFC;

lib/AST/ASTDiagnostic.cpp

case DiagnosticsEngine::ak_qualtype_pair: {
           QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.FromType));
       QualType ToType =
           QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.ToType));
 
       if (FormatTemplateTypeDiff(Context, FromType, ToType, TDT.PrintTree,
                                  TDT.PrintFromType, TDT.ElideType,
                                  TDT.ShowColors, OS)) {
         NeedQuotes = !TDT.PrintTree;
-        TDT.TemplateDiffUsed = true;
+        TDT.TemplateDiffUsed = 1;
         break;
       }
 
       // Don't fall-back during tree printing.  The caller will handle
       // this case.
       if (TDT.PrintTree)
         return;
 

lib/AST/Comment.cpp

 }
 
 void DeclInfo::fill() {
   assert(!IsFilled);
 
   // Set defaults.
   Kind = OtherKind;
   TemplateKind = NotTemplate;
-  IsObjCMethod = false;
-  IsInstanceMethod = false;
-  IsClassMethod = false;
+  IsObjCMethod = 0;
+  IsInstanceMethod = 0;
+  IsClassMethod = 0;
   ParamVars = None;
   TemplateParameters = nullptr;
 
   if (!CommentDecl) {
     // If there is no declaration, the defaults is our only guess.
-    IsFilled = true;
+    IsFilled = 1;
     return;
   }
   CurrentDecl = CommentDecl;
   
   Decl::Kind K = CommentDecl->getKind();
   switch (K) {
   default:
     // Defaults are should be good for declarations we don't handle explicitly.
case Decl::CXXConversion: {
     }
     break;
   }
   case Decl::ObjCMethod: {
     const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(CommentDecl);
     Kind = FunctionKind;
     ParamVars = llvm::makeArrayRef(MD->param_begin(), MD->param_size());
     ReturnType = MD->getReturnType();
-    IsObjCMethod = true;
+    IsObjCMethod = 1;
     IsInstanceMethod = MD->isInstanceMethod();
     IsClassMethod = !IsInstanceMethod;
     break;
   }
   case Decl::FunctionTemplate: {
     const FunctionTemplateDecl *FTD = cast<FunctionTemplateDecl>(CommentDecl);
     Kind = FunctionKind;
     TemplateKind = Template;
case Decl::TypeAliasTemplate: {
     TemplateParameters = TAT->getTemplateParameters();
     break;
   }
   case Decl::Enum:
     Kind = EnumKind;
     break;
   }
 
-  IsFilled = true;
+  IsFilled = 1;
 }
 
 StringRef ParamCommandComment::getParamName(const FullComment *FC) const {
   assert(isParamIndexValid());
   if (isVarArgParam())
     return "...";
   return FC->getDeclInfo()->ParamVars[getParamIndex()]->getName();
 }

lib/AST/CommentCommandTraits.cpp

CommandInfo *CommandTraits::createCommandInfoWithName(StringRef CommandName) {
   RegisteredCommands.push_back(Info);
 
   return Info;
 }
 
 const CommandInfo *CommandTraits::registerUnknownCommand(
                                                   StringRef CommandName) {
   CommandInfo *Info = createCommandInfoWithName(CommandName);
-  Info->IsUnknownCommand = true;
+  Info->IsUnknownCommand = 1;
   return Info;
 }
 
 const CommandInfo *CommandTraits::registerBlockCommand(StringRef CommandName) {
   CommandInfo *Info = createCommandInfoWithName(CommandName);
-  Info->IsBlockCommand = true;
+  Info->IsBlockCommand = 1;
   return Info;
 }
 
 const CommandInfo *CommandTraits::getBuiltinCommandInfo(
                                                   unsigned CommandID) {
   if (CommandID < llvm::array_lengthof(Commands))
     return &Commands[CommandID];
   return nullptr;

lib/AST/CommentSema.cpp

 }
 
 void Sema::setDecl(const Decl *D) {
   if (!D)
     return;
 
   ThisDeclInfo = new (Allocator) DeclInfo;
   ThisDeclInfo->CommentDecl = D;
-  ThisDeclInfo->IsFilled = false;
+  ThisDeclInfo->IsFilled = 0;
 }
 
 ParagraphComment *Sema::actOnParagraphComment(
                               ArrayRef<InlineContentComment *> Content) {
   return new (Allocator) ParagraphComment(Content);
 }
 
 BlockCommandComment *Sema::actOnBlockCommandStart(

lib/AST/Decl.cpp

   if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
     FunctionTemplateDecl *PrevFunTmpl
       = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
     assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
     FunTmpl->setPreviousDecl(PrevFunTmpl);
   }
   
   if (PrevDecl && PrevDecl->IsInline)
-    IsInline = true;
+    IsInline = 1;
 }
 
 FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
 
 /// \brief Returns a value indicating whether this function
 /// corresponds to a builtin function.
 ///
 /// The function corresponds to a built-in function if it is

lib/AST/DeclBase.cpp

 
 void Decl::markUsed(ASTContext &C) {
   if (Used)
     return;
 
   if (C.getASTMutationListener())
     C.getASTMutationListener()->DeclarationMarkedUsed(this);
 
-  Used = true;
+  Used = 1;
 }
 
 bool Decl::isReferenced() const { 
   if (Referenced)
     return true;
 
   // Check redeclarations.
   for (auto I : redecls())

 
 void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
   assert(!HasAttrs && "Decl already contains attrs.");
 
   AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
   assert(AttrBlank.empty() && "HasAttrs was wrong?");
 
   AttrBlank = attrs;
-  HasAttrs = true;
+  HasAttrs = 1;
 }
 
 void Decl::dropAttrs() {
   if (!HasAttrs) return;
 
-  HasAttrs = false;
+  HasAttrs = 0;
   getASTContext().eraseDeclAttrs(this);
 }
 
 const AttrVec &Decl::getAttrs() const {
   assert(HasAttrs && "No attrs to get!");
   return getASTContext().getDeclAttrs(this);
 }
 

lib/AST/DeclCXX.cpp

void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const {
 
   for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); ++I)
     I.setDecl(cast<NamedDecl>(Source->GetExternalDecl(
         reinterpret_cast<uintptr_t>(I.getDecl()) >> 2)));
   Impl.Decls.setLazy(false);
 }
 
 CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
-    : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
-      Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
-      Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
-      HasPrivateFields(false), HasProtectedFields(false),
-      HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),
-      HasOnlyCMembers(true), HasInClassInitializer(false),
-      HasUninitializedReferenceMember(false), HasUninitializedFields(false),
-      NeedOverloadResolutionForMoveConstructor(false),
-      NeedOverloadResolutionForMoveAssignment(false),
-      NeedOverloadResolutionForDestructor(false),
-      DefaultedMoveConstructorIsDeleted(false),
-      DefaultedMoveAssignmentIsDeleted(false),
-      DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All),
-      DeclaredNonTrivialSpecialMembers(0), HasIrrelevantDestructor(true),
-      HasConstexprNonCopyMoveConstructor(false),
-      HasDefaultedDefaultConstructor(false),
-      DefaultedDefaultConstructorIsConstexpr(true),
-      HasConstexprDefaultConstructor(false),
-      HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
-      UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
-      ImplicitCopyConstructorHasConstParam(true),
-      ImplicitCopyAssignmentHasConstParam(true),
-      HasDeclaredCopyConstructorWithConstParam(false),
-      HasDeclaredCopyAssignmentWithConstParam(false), IsLambda(false),
-      IsParsingBaseSpecifiers(false), NumBases(0), NumVBases(0), Bases(),
+    : UserDeclaredConstructor(0), UserDeclaredSpecialMembers(0),
+      Aggregate(1), PlainOldData(1), Empty(1), Polymorphic(0),
+      Abstract(0), IsStandardLayout(1), HasNoNonEmptyBases(1),
+      HasPrivateFields(0), HasProtectedFields(0),
+      HasPublicFields(0), HasMutableFields(0), HasVariantMembers(0),
+      HasOnlyCMembers(1), HasInClassInitializer(0),
+      HasUninitializedReferenceMember(0), HasUninitializedFields(0),
+      NeedOverloadResolutionForMoveConstructor(0),
+      NeedOverloadResolutionForMoveAssignment(0),
+      NeedOverloadResolutionForDestructor(0),
+      DefaultedMoveConstructorIsDeleted(0),
+      DefaultedMoveAssignmentIsDeleted(0),
+      DefaultedDestructorIsDeleted(0), HasTrivialSpecialMembers(SMF_All),
+      DeclaredNonTrivialSpecialMembers(0), HasIrrelevantDestructor(1),
+      HasConstexprNonCopyMoveConstructor(0),
+      HasDefaultedDefaultConstructor(0),
+      DefaultedDefaultConstructorIsConstexpr(1),
+      HasConstexprDefaultConstructor(0),
+      HasNonLiteralTypeFieldsOrBases(0), ComputedVisibleConversions(0),
+      UserProvidedDefaultConstructor(0), DeclaredSpecialMembers(0),
+      ImplicitCopyConstructorHasConstParam(1),
+      ImplicitCopyAssignmentHasConstParam(1),
+      HasDeclaredCopyConstructorWithConstParam(0),
+      HasDeclaredCopyAssignmentWithConstParam(0), IsLambda(0),
+      IsParsingBaseSpecifiers(0), NumBases(0), NumVBases(0), Bases(),
       VBases(), Definition(D), FirstFriend() {}
 
 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
   return Bases.get(Definition->getASTContext().getExternalSource());
 }
 
 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
   return VBases.get(Definition->getASTContext().getExternalSource());
CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
 
   if (!data().Bases.isOffset() && data().NumBases > 0)
     C.Deallocate(data().getBases());
 
   if (NumBases) {
     if (!C.getLangOpts().CPlusPlus1z) {
       // C++ [dcl.init.aggr]p1:
       //   An aggregate is [...] a class with [...] no base classes [...].
-      data().Aggregate = false;
+      data().Aggregate = 0;
     }
 
     // C++ [class]p4:
     //   A POD-struct is an aggregate class...
-    data().PlainOldData = false;
+    data().PlainOldData = 0;
   }
 
   // The set of seen virtual base types.
   llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
   
   // The virtual bases of this class.
   SmallVector<const CXXBaseSpecifier *, 8> VBases;
 
if (!BaseClassDecl->isEmpty()) {
         // C++0x [class]p7:
         //   A standard-layout class is a class that:
         //    [...]
         //    -- either has no non-static data members in the most derived
         //       class and at most one base class with non-static data members,
         //       or has no base classes with non-static data members, and
         // If this is the second non-empty base, then neither of these two
         // clauses can be true.
-        data().IsStandardLayout = false;
+        data().IsStandardLayout = 0;
       }
 
-      data().Empty = false;
-      data().HasNoNonEmptyBases = false;
+      data().Empty = 0;
+      data().HasNoNonEmptyBases = 0;
     }
     
     // C++1z [dcl.init.agg]p1:
     //   An aggregate is a class with [...] no private or protected base classes
     if (Base->getAccessSpecifier() != AS_public)
-      data().Aggregate = false;
+      data().Aggregate = 0;
 
     // C++ [class.virtual]p1:
     //   A class that declares or inherits a virtual function is called a 
     //   polymorphic class.
     if (BaseClassDecl->isPolymorphic())
-      data().Polymorphic = true;
+      data().Polymorphic = 1;
 
     // C++0x [class]p7:
     //   A standard-layout class is a class that: [...]
     //    -- has no non-standard-layout base classes
     if (!BaseClassDecl->isStandardLayout())
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
 
     // Record if this base is the first non-literal field or base.
     if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C))
-      data().HasNonLiteralTypeFieldsOrBases = true;
+      data().HasNonLiteralTypeFieldsOrBases = 1;
     
     // Now go through all virtual bases of this base and add them.
     for (const auto &VBase : BaseClassDecl->vbases()) {
       // Add this base if it's not already in the list.
       if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
         VBases.push_back(&VBase);
 
         // C++11 [class.copy]p8:
         //   The implicitly-declared copy constructor for a class X will have
         //   the form 'X::X(const X&)' if each [...] virtual base class B of X
         //   has a copy constructor whose first parameter is of type
         //   'const B&' or 'const volatile B&' [...]
         if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())
           if (!VBaseDecl->hasCopyConstructorWithConstParam())
-            data().ImplicitCopyConstructorHasConstParam = false;
+            data().ImplicitCopyConstructorHasConstParam = 0;
 
         // C++1z [dcl.init.agg]p1:
         //   An aggregate is a class with [...] no virtual base classes
-        data().Aggregate = false;
+        data().Aggregate = 0;
       }
     }
 
     if (Base->isVirtual()) {
       // Add this base if it's not already in the list.
       if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
         VBases.push_back(Base);
 
       // C++11 [meta.unary.prop] is_empty:
       //    T is a class type, but not a union type, with ... no virtual base
       //    classes
-      data().Empty = false;
+      data().Empty = 0;
 
       // C++1z [dcl.init.agg]p1:
       //   An aggregate is a class with [...] no virtual base classes
-      data().Aggregate = false;
+      data().Aggregate = 0;
 
       // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
       //   A [default constructor, copy/move constructor, or copy/move assignment
       //   operator for a class X] is trivial [...] if:
       //    -- class X has [...] no virtual base classes
       data().HasTrivialSpecialMembers &= SMF_Destructor;
 
       // C++0x [class]p7:
       //   A standard-layout class is a class that: [...]
       //    -- has [...] no virtual base classes
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
 
       // C++11 [dcl.constexpr]p4:
       //   In the definition of a constexpr constructor [...]
       //    -- the class shall not have any virtual base classes
-      data().DefaultedDefaultConstructorIsConstexpr = false;
+      data().DefaultedDefaultConstructorIsConstexpr = 0;
     } else {
       // C++ [class.ctor]p5:
       //   A default constructor is trivial [...] if:
       //    -- all the direct base classes of its class have trivial default
       //       constructors.
       if (!BaseClassDecl->hasTrivialDefaultConstructor())
         data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
 
if (Base->isVirtual()) {
       if (!BaseClassDecl->hasTrivialMoveAssignment())
         data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
 
       // C++11 [class.ctor]p6:
       //   If that user-written default constructor would satisfy the
       //   requirements of a constexpr constructor, the implicitly-defined
       //   default constructor is constexpr.
       if (!BaseClassDecl->hasConstexprDefaultConstructor())
-        data().DefaultedDefaultConstructorIsConstexpr = false;
+        data().DefaultedDefaultConstructorIsConstexpr = 0;
     }
 
     // C++ [class.ctor]p3:
     //   A destructor is trivial if all the direct base classes of its class
     //   have trivial destructors.
     if (!BaseClassDecl->hasTrivialDestructor())
       data().HasTrivialSpecialMembers &= ~SMF_Destructor;
 
     if (!BaseClassDecl->hasIrrelevantDestructor())
-      data().HasIrrelevantDestructor = false;
+      data().HasIrrelevantDestructor = 0;
 
     // C++11 [class.copy]p18:
     //   The implicitly-declared copy assignment oeprator for a class X will
     //   have the form 'X& X::operator=(const X&)' if each direct base class B
     //   of X has a copy assignment operator whose parameter is of type 'const
     //   B&', 'const volatile B&', or 'B' [...]
     if (!BaseClassDecl->hasCopyAssignmentWithConstParam())
-      data().ImplicitCopyAssignmentHasConstParam = false;
+      data().ImplicitCopyAssignmentHasConstParam = 0;
 
     // C++11 [class.copy]p8:
     //   The implicitly-declared copy constructor for a class X will have
     //   the form 'X::X(const X&)' if each direct [...] base class B of X
     //   has a copy constructor whose first parameter is of type
     //   'const B&' or 'const volatile B&' [...]
     if (!BaseClassDecl->hasCopyConstructorWithConstParam())
-      data().ImplicitCopyConstructorHasConstParam = false;
+      data().ImplicitCopyConstructorHasConstParam = 0;
 
     // A class has an Objective-C object member if... or any of its bases
     // has an Objective-C object member.
     if (BaseClassDecl->hasObjectMember())
       setHasObjectMember(true);
     
     if (BaseClassDecl->hasVolatileMember())
       setHasVolatileMember(true);
 
     // Keep track of the presence of mutable fields.
     if (BaseClassDecl->hasMutableFields())
-      data().HasMutableFields = true;
+      data().HasMutableFields = 1;
 
     if (BaseClassDecl->hasUninitializedReferenceMember())
-      data().HasUninitializedReferenceMember = true;
+      data().HasUninitializedReferenceMember = 1;
 
     if (!BaseClassDecl->allowConstDefaultInit())
-      data().HasUninitializedFields = true;
+      data().HasUninitializedFields = 1;
 
     addedClassSubobject(BaseClassDecl);
   }
   
   if (VBases.empty()) {
-    data().IsParsingBaseSpecifiers = false;
+    data().IsParsingBaseSpecifiers = 0;
     return;
   }
 
   // Create base specifier for any direct or indirect virtual bases.
   data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
   data().NumVBases = VBases.size();
   for (int I = 0, E = VBases.size(); I != E; ++I) {
     QualType Type = VBases[I]->getType();
     if (!Type->isDependentType())
       addedClassSubobject(Type->getAsCXXRecordDecl());
     data().getVBases()[I] = *VBases[I];
   }
 
-  data().IsParsingBaseSpecifiers = false;
+  data().IsParsingBaseSpecifiers = 0;
 }
 
 void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) {
   // C++11 [class.copy]p11:
   //   A defaulted copy/move constructor for a class X is defined as
   //   deleted if X has:
   //    -- a direct or virtual base class B that cannot be copied/moved [...]
   //    -- a non-static data member of class type M (or array thereof)
   //       that cannot be copied or moved [...]
   if (!Subobj->hasSimpleMoveConstructor())
-    data().NeedOverloadResolutionForMoveConstructor = true;
+    data().NeedOverloadResolutionForMoveConstructor = 1;
 
   // C++11 [class.copy]p23:
   //   A defaulted copy/move assignment operator for a class X is defined as
   //   deleted if X has:
   //    -- a direct or virtual base class B that cannot be copied/moved [...]
   //    -- a non-static data member of class type M (or array thereof)
   //        that cannot be copied or moved [...]
   if (!Subobj->hasSimpleMoveAssignment())
-    data().NeedOverloadResolutionForMoveAssignment = true;
+    data().NeedOverloadResolutionForMoveAssignment = 1;
 
   // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5:
   //   A defaulted [ctor or dtor] for a class X is defined as
   //   deleted if X has:
   //    -- any direct or virtual base class [...] has a type with a destructor
   //       that is deleted or inaccessible from the defaulted [ctor or dtor].
   //    -- any non-static data member has a type with a destructor
   //       that is deleted or inaccessible from the defaulted [ctor or dtor].
   if (!Subobj->hasSimpleDestructor()) {
-    data().NeedOverloadResolutionForMoveConstructor = true;
-    data().NeedOverloadResolutionForDestructor = true;
+    data().NeedOverloadResolutionForMoveConstructor = 1;
+    data().NeedOverloadResolutionForDestructor = 1;
   }
 }
 
 bool CXXRecordDecl::hasAnyDependentBases() const {
   if (!isDependentContext())
     return false;
 
   return !forallBases([](const CXXRecordDecl *) { return true; });
bool CXXRecordDecl::isTriviallyCopyable() const {
   if (!hasTrivialDestructor()) return false;
 
   return true;
 }
 
 void CXXRecordDecl::markedVirtualFunctionPure() {
   // C++ [class.abstract]p2: 
   //   A class is abstract if it has at least one pure virtual function.
-  data().Abstract = true;
+  data().Abstract = 1;
 }
 
 void CXXRecordDecl::addedMember(Decl *D) {
   if (!D->isImplicit() &&
       !isa<FieldDecl>(D) &&
       !isa<IndirectFieldDecl>(D) &&
       (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
         cast<TagDecl>(D)->getTagKind() == TTK_Interface))
-    data().HasOnlyCMembers = false;
+    data().HasOnlyCMembers = 0;
 
   // Ignore friends and invalid declarations.
   if (D->getFriendObjectKind() || D->isInvalidDecl())
     return;
   
   FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
   if (FunTmpl)
     D = FunTmpl->getTemplatedDecl();
   
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (Method->isVirtual()) {
       // C++ [dcl.init.aggr]p1:
       //   An aggregate is an array or a class with [...] no virtual functions.
-      data().Aggregate = false;
+      data().Aggregate = 0;
       
       // C++ [class]p4:
       //   A POD-struct is an aggregate class...
-      data().PlainOldData = false;
+      data().PlainOldData = 0;
       
       // Virtual functions make the class non-empty.
       // FIXME: Standard ref?
-      data().Empty = false;
+      data().Empty = 0;
 
       // C++ [class.virtual]p1:
       //   A class that declares or inherits a virtual function is called a 
       //   polymorphic class.
-      data().Polymorphic = true;
+      data().Polymorphic = 1;
 
       // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
       //   A [default constructor, copy/move constructor, or copy/move
       //   assignment operator for a class X] is trivial [...] if:
       //    -- class X has no virtual functions [...]
       data().HasTrivialSpecialMembers &= SMF_Destructor;
 
       // C++0x [class]p7:
       //   A standard-layout class is a class that: [...]
       //    -- has no virtual functions
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
     }
   }
 
   // Notify the listener if an implicit member was added after the definition
   // was completed.
   if (!isBeingDefined() && D->isImplicit())
     if (ASTMutationListener *L = getASTMutationListener())
       L->AddedCXXImplicitMember(data().Definition, D);
 
   // The kind of special member this declaration is, if any.
   unsigned SMKind = 0;
 
   // Handle constructors.
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (!Constructor->isImplicit()) {
       // Note that we have a user-declared constructor.
-      data().UserDeclaredConstructor = true;
+      data().UserDeclaredConstructor = 1;
 
       // C++ [class]p4:
       //   A POD-struct is an aggregate class [...]
       // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
       // type is technically an aggregate in C++0x since it wouldn't be in 03.
-      data().PlainOldData = false;
+      data().PlainOldData = 0;
     }
 
     // Technically, "user-provided" is only defined for special member
     // functions, but the intent of the standard is clearly that it should apply
     // to all functions.
     bool UserProvided = Constructor->isUserProvided();
 
     if (Constructor->isDefaultConstructor()) {
       SMKind |= SMF_DefaultConstructor;
 
       if (UserProvided)
-        data().UserProvidedDefaultConstructor = true;
+        data().UserProvidedDefaultConstructor = 1;
       if (Constructor->isConstexpr())
-        data().HasConstexprDefaultConstructor = true;
+        data().HasConstexprDefaultConstructor = 1;
       if (Constructor->isDefaulted())
-        data().HasDefaultedDefaultConstructor = true;
+        data().HasDefaultedDefaultConstructor = 1;
     }
 
     if (!FunTmpl) {
       unsigned Quals;
       if (Constructor->isCopyConstructor(Quals)) {
         SMKind |= SMF_CopyConstructor;
 
         if (Quals & Qualifiers::Const)
-          data().HasDeclaredCopyConstructorWithConstParam = true;
+          data().HasDeclaredCopyConstructorWithConstParam = 1;
       } else if (Constructor->isMoveConstructor())
         SMKind |= SMF_MoveConstructor;
     }
 
     // Record if we see any constexpr constructors which are neither copy
     // nor move constructors.
     if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
-      data().HasConstexprNonCopyMoveConstructor = true;
+      data().HasConstexprNonCopyMoveConstructor = 1;
 
     // C++ [dcl.init.aggr]p1:
     //   An aggregate is an array or a class with no user-declared
     //   constructors [...].
     // C++11 [dcl.init.aggr]p1:
     //   An aggregate is an array or a class with no user-provided
     //   constructors [...].
     if (getASTContext().getLangOpts().CPlusPlus11
           ? UserProvided : !Constructor->isImplicit())
-      data().Aggregate = false;
+      data().Aggregate = 0;
   }
 
   // Handle destructors.
   if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
     SMKind |= SMF_Destructor;
 
     if (DD->isUserProvided())
-      data().HasIrrelevantDestructor = false;
+      data().HasIrrelevantDestructor = 0;
     // If the destructor is explicitly defaulted and not trivial or not public
     // or if the destructor is deleted, we clear HasIrrelevantDestructor in
     // finishedDefaultedOrDeletedMember.
 
     // C++11 [class.dtor]p5:
     //   A destructor is trivial if [...] the destructor is not virtual.
     if (DD->isVirtual())
       data().HasTrivialSpecialMembers &= ~SMF_Destructor;
   }
 
   // Handle member functions.
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (Method->isCopyAssignmentOperator()) {
       SMKind |= SMF_CopyAssignment;
 
       const ReferenceType *ParamTy =
         Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
       if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
-        data().HasDeclaredCopyAssignmentWithConstParam = true;
+        data().HasDeclaredCopyAssignmentWithConstParam = 1;
     }
 
     if (Method->isMoveAssignmentOperator())
       SMKind |= SMF_MoveAssignment;
 
     // Keep the list of conversion functions up-to-date.
     if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
       // FIXME: We use the 'unsafe' accessor for the access specifier here,
if (SMKind) {
         //
         // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
         // aggregates could not have any constructors, clear it even for an
         // explicitly defaulted or deleted constructor.
         // type is technically an aggregate in C++0x since it wouldn't be in 03.
         //
         // Also, a user-declared move assignment operator makes a class non-POD.
         // This is an extension in C++03.
-        data().PlainOldData = false;
+        data().PlainOldData = 0;
       }
     }
 
     return;
   }
 
   // Handle non-static data members.
   if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
     // C++ [class.bit]p2:
     //   A declaration for a bit-field that omits the identifier declares an 
     //   unnamed bit-field. Unnamed bit-fields are not members and cannot be 
     //   initialized.
     if (Field->isUnnamedBitfield())
       return;
     
     // C++ [dcl.init.aggr]p1:
     //   An aggregate is an array or a class (clause 9) with [...] no
     //   private or protected non-static data members (clause 11).
     //
     // A POD must be an aggregate.    
     if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
-      data().Aggregate = false;
-      data().PlainOldData = false;
+      data().Aggregate = 0;
+      data().PlainOldData = 0;
     }
 
     // C++0x [class]p7:
     //   A standard-layout class is a class that:
     //    [...]
     //    -- has the same access control for all non-static data members,
     switch (D->getAccess()) {
-    case AS_private:    data().HasPrivateFields = true;   break;
-    case AS_protected:  data().HasProtectedFields = true; break;
-    case AS_public:     data().HasPublicFields = true;    break;
+    case AS_private:    data().HasPrivateFields = 1;   break;
+    case AS_protected:  data().HasProtectedFields = 1; break;
+    case AS_public:     data().HasPublicFields = 1;    break;
     case AS_none:       llvm_unreachable("Invalid access specifier");
     };
     if ((data().HasPrivateFields + data().HasProtectedFields +
          data().HasPublicFields) > 1)
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
 
     // Keep track of the presence of mutable fields.
     if (Field->isMutable())
-      data().HasMutableFields = true;
+      data().HasMutableFields = 1;
 
     // C++11 [class.union]p8, DR1460:
     //   If X is a union, a non-static data member of X that is not an anonymous
     //   union is a variant member of X.
     if (isUnion() && !Field->isAnonymousStructOrUnion())
-      data().HasVariantMembers = true;
+      data().HasVariantMembers = 1;
 
     // C++0x [class]p9:
     //   A POD struct is a class that is both a trivial class and a 
     //   standard-layout class, and has no non-static data members of type 
     //   non-POD struct, non-POD union (or array of such types).
     //
     // Automatic Reference Counting: the presence of a member of Objective-C pointer type
     // that does not explicitly have no lifetime makes the class a non-POD.
     ASTContext &Context = getASTContext();
     QualType T = Context.getBaseElementType(Field->getType());
     if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
       if (!Context.getLangOpts().ObjCAutoRefCount) {
         setHasObjectMember(true);
       } else if (T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) {
         // Objective-C Automatic Reference Counting:
         //   If a class has a non-static data member of Objective-C pointer
         //   type (or array thereof), it is a non-POD type and its
         //   default constructor (if any), copy constructor, move constructor,
         //   copy assignment operator, move assignment operator, and destructor are
         //   non-trivial.
         setHasObjectMember(true);
         struct DefinitionData &Data = data();
-        Data.PlainOldData = false;
+        Data.PlainOldData = 0;
         Data.HasTrivialSpecialMembers = 0;
-        Data.HasIrrelevantDestructor = false;
+        Data.HasIrrelevantDestructor = 0;
       }
     } else if (!T.isCXX98PODType(Context))
-      data().PlainOldData = false;
+      data().PlainOldData = 0;
     
     if (T->isReferenceType()) {
       if (!Field->hasInClassInitializer())
-        data().HasUninitializedReferenceMember = true;
+        data().HasUninitializedReferenceMember = 1;
 
       // C++0x [class]p7:
       //   A standard-layout class is a class that:
       //    -- has no non-static data members of type [...] reference,
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
     }
 
     if (!Field->hasInClassInitializer() && !Field->isMutable()) {
       if (CXXRecordDecl *FieldType = Field->getType()->getAsCXXRecordDecl()) {
         if (FieldType->hasDefinition() && !FieldType->allowConstDefaultInit())
-          data().HasUninitializedFields = true;
+          data().HasUninitializedFields = 1;
       } else {
-        data().HasUninitializedFields = true;
+        data().HasUninitializedFields = 1;
       }
     }
 
     // Record if this field is the first non-literal or volatile field or base.
     if (!T->isLiteralType(Context) || T.isVolatileQualified())
-      data().HasNonLiteralTypeFieldsOrBases = true;
+      data().HasNonLiteralTypeFieldsOrBases = 1;
 
     if (Field->hasInClassInitializer() ||
         (Field->isAnonymousStructOrUnion() &&
          Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
-      data().HasInClassInitializer = true;
+      data().HasInClassInitializer = 1;
 
       // C++11 [class]p5:
       //   A default constructor is trivial if [...] no non-static data member
       //   of its class has a brace-or-equal-initializer.
       data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
 
       // C++11 [dcl.init.aggr]p1:
       //   An aggregate is a [...] class with [...] no
       //   brace-or-equal-initializers for non-static data members.
       //
       // This rule was removed in C++14.
       if (!getASTContext().getLangOpts().CPlusPlus14)
-        data().Aggregate = false;
+        data().Aggregate = 0;
 
       // C++11 [class]p10:
       //   A POD struct is [...] a trivial class.
-      data().PlainOldData = false;
+      data().PlainOldData = 0;
     }
 
     // C++11 [class.copy]p23:
     //   A defaulted copy/move assignment operator for a class X is defined
     //   as deleted if X has:
     //    -- a non-static data member of reference type
     if (T->isReferenceType())
-      data().DefaultedMoveAssignmentIsDeleted = true;
+      data().DefaultedMoveAssignmentIsDeleted = 1;
 
     if (const RecordType *RecordTy = T->getAs<RecordType>()) {
       CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
       if (FieldRec->getDefinition()) {
         addedClassSubobject(FieldRec);
 
         // We may need to perform overload resolution to determine whether a
         // field can be moved if it's const or volatile qualified.
         if (T.getCVRQualifiers() & (Qualifiers::Const | Qualifiers::Volatile)) {
-          data().NeedOverloadResolutionForMoveConstructor = true;
-          data().NeedOverloadResolutionForMoveAssignment = true;
+          data().NeedOverloadResolutionForMoveConstructor = 1;
+          data().NeedOverloadResolutionForMoveAssignment = 1;
         }
 
         // C++11 [class.ctor]p5, C++11 [class.copy]p11:
         //   A defaulted [special member] for a class X is defined as
         //   deleted if:
         //    -- X is a union-like class that has a variant member with a
         //       non-trivial [corresponding special member]
         if (isUnion()) {
           if (FieldRec->hasNonTrivialMoveConstructor())
-            data().DefaultedMoveConstructorIsDeleted = true;
+            data().DefaultedMoveConstructorIsDeleted = 1;
           if (FieldRec->hasNonTrivialMoveAssignment())
-            data().DefaultedMoveAssignmentIsDeleted = true;
+            data().DefaultedMoveAssignmentIsDeleted = 1;
           if (FieldRec->hasNonTrivialDestructor())
-            data().DefaultedDestructorIsDeleted = true;
+            data().DefaultedDestructorIsDeleted = 1;
         }
 
         // C++0x [class.ctor]p5:
         //   A default constructor is trivial [...] if:
         //    -- for all the non-static data members of its class that are of
         //       class type (or array thereof), each such class has a trivial
         //       default constructor.
         if (!FieldRec->hasTrivialDefaultConstructor())
if (const RecordType *RecordTy = T->getAs<RecordType>()) {
         // declare the move assignment for this class and we'll decide whether
         // it's trivial then.
         if (!FieldRec->hasTrivialMoveAssignment())
           data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
 
         if (!FieldRec->hasTrivialDestructor())
           data().HasTrivialSpecialMembers &= ~SMF_Destructor;
         if (!FieldRec->hasIrrelevantDestructor())
-          data().HasIrrelevantDestructor = false;
+          data().HasIrrelevantDestructor = 0;
         if (FieldRec->hasObjectMember())
           setHasObjectMember(true);
         if (FieldRec->hasVolatileMember())
           setHasVolatileMember(true);
 
         // C++0x [class]p7:
         //   A standard-layout class is a class that:
         //    -- has no non-static data members of type non-standard-layout
         //       class (or array of such types) [...]
         if (!FieldRec->isStandardLayout())
-          data().IsStandardLayout = false;
+          data().IsStandardLayout = 0;
 
         // C++0x [class]p7:
         //   A standard-layout class is a class that:
         //    [...]
         //    -- has no base classes of the same type as the first non-static
         //       data member.
         // We don't want to expend bits in the state of the record decl
         // tracking whether this is the first non-static data member so we
         // cheat a bit and use some of the existing state: the empty bit.
         // Virtual bases and virtual methods make a class non-empty, but they
         // also make it non-standard-layout so we needn't check here.
         // A non-empty base class may leave the class standard-layout, but not
         // if we have arrived here, and have at least one non-static data
         // member. If IsStandardLayout remains true, then the first non-static
         // data member must come through here with Empty still true, and Empty
         // will subsequently be set to false below.
         if (data().IsStandardLayout && data().Empty) {
           for (const auto &BI : bases()) {
             if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
-              data().IsStandardLayout = false;
+              data().IsStandardLayout = 0;
               break;
             }
           }
         }
         
         // Keep track of the presence of mutable fields.
         if (FieldRec->hasMutableFields())
-          data().HasMutableFields = true;
+          data().HasMutableFields = 1;
 
         // C++11 [class.copy]p13:
         //   If the implicitly-defined constructor would satisfy the
         //   requirements of a constexpr constructor, the implicitly-defined
         //   constructor is constexpr.
         // C++11 [dcl.constexpr]p4:
         //    -- every constructor involved in initializing non-static data
         //       members [...] shall be a constexpr constructor
         if (!Field->hasInClassInitializer() &&
             !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
           // The standard requires any in-class initializer to be a constant
           // expression. We consider this to be a defect.
-          data().DefaultedDefaultConstructorIsConstexpr = false;
+          data().DefaultedDefaultConstructorIsConstexpr = 0;
 
         // C++11 [class.copy]p8:
         //   The implicitly-declared copy constructor for a class X will have
         //   the form 'X::X(const X&)' if [...] for all the non-static data
         //   members of X that are of a class type M (or array thereof), each
         //   such class type has a copy constructor whose first parameter is
         //   of type 'const M&' or 'const volatile M&'.
         if (!FieldRec->hasCopyConstructorWithConstParam())
-          data().ImplicitCopyConstructorHasConstParam = false;
+          data().ImplicitCopyConstructorHasConstParam = 0;
 
         // C++11 [class.copy]p18:
         //   The implicitly-declared copy assignment oeprator for a class X will
         //   have the form 'X& X::operator=(const X&)' if [...] for all the
         //   non-static data members of X that are of a class type M (or array
         //   thereof), each such class type has a copy assignment operator whose
         //   parameter is of type 'const M&', 'const volatile M&' or 'M'.
         if (!FieldRec->hasCopyAssignmentWithConstParam())
-          data().ImplicitCopyAssignmentHasConstParam = false;
+          data().ImplicitCopyAssignmentHasConstParam = 0;
 
         if (FieldRec->hasUninitializedReferenceMember() &&
             !Field->hasInClassInitializer())
-          data().HasUninitializedReferenceMember = true;
+          data().HasUninitializedReferenceMember = 1;
 
         // C++11 [class.union]p8, DR1460:
         //   a non-static data member of an anonymous union that is a member of
         //   X is also a variant member of X.
         if (FieldRec->hasVariantMembers() &&
             Field->isAnonymousStructOrUnion())
-          data().HasVariantMembers = true;
+          data().HasVariantMembers = 1;
       }
     } else {
       // Base element type of field is a non-class type.
       if (!T->isLiteralType(Context) ||
           (!Field->hasInClassInitializer() && !isUnion()))
-        data().DefaultedDefaultConstructorIsConstexpr = false;
+        data().DefaultedDefaultConstructorIsConstexpr = 0;
 
       // C++11 [class.copy]p23:
       //   A defaulted copy/move assignment operator for a class X is defined
       //   as deleted if X has:
       //    -- a non-static data member of const non-class type (or array
       //       thereof)
       if (T.isConstQualified())
-        data().DefaultedMoveAssignmentIsDeleted = true;
+        data().DefaultedMoveAssignmentIsDeleted = 1;
     }
 
     // C++0x [class]p7:
     //   A standard-layout class is a class that:
     //    [...]
     //    -- either has no non-static data members in the most derived
     //       class and at most one base class with non-static data members,
     //       or has no base classes with non-static data members, and
     // At this point we know that we have a non-static data member, so the last
     // clause holds.
     if (!data().HasNoNonEmptyBases)
-      data().IsStandardLayout = false;
+      data().IsStandardLayout = 0;
 
     // If this is not a zero-length bit-field, then the class is not empty.
     if (data().Empty) {
       if (!Field->isBitField() ||
           (!Field->getBitWidth()->isTypeDependent() &&
            !Field->getBitWidth()->isValueDependent() &&
            Field->getBitWidthValue(Context) != 0))
-        data().Empty = false;
+        data().Empty = 0;
     }
   }
   
   // Handle using declarations of conversion functions.
   if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D)) {
     if (Shadow->getDeclName().getNameKind()
           == DeclarationName::CXXConversionFunctionName) {
       ASTContext &Ctx = getASTContext();
       data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
     }
   }
 }
 
 void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
   assert(!D->isImplicit() && !D->isUserProvided());
 
   // The kind of special member this declaration is, if any.
   unsigned SMKind = 0;
 
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (Constructor->isDefaultConstructor()) {
       SMKind |= SMF_DefaultConstructor;
       if (Constructor->isConstexpr())
-        data().HasConstexprDefaultConstructor = true;
+        data().HasConstexprDefaultConstructor = 1;
     }
     if (Constructor->isCopyConstructor())
       SMKind |= SMF_CopyConstructor;
     else if (Constructor->isMoveConstructor())
       SMKind |= SMF_MoveConstructor;
     else if (Constructor->isConstexpr())
       // We may now know that the constructor is constexpr.
-      data().HasConstexprNonCopyMoveConstructor = true;
+      data().HasConstexprNonCopyMoveConstructor = 1;
   } else if (isa<CXXDestructorDecl>(D)) {
     SMKind |= SMF_Destructor;
     if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
-      data().HasIrrelevantDestructor = false;
+      data().HasIrrelevantDestructor = 0;
   } else if (D->isCopyAssignmentOperator())
     SMKind |= SMF_CopyAssignment;
   else if (D->isMoveAssignmentOperator())
     SMKind |= SMF_MoveAssignment;
 
   // Update which trivial / non-trivial special members we have.
   // addedMember will have skipped this step for this member.
   if (D->isTrivial())
CXXRecordDecl::getVisibleConversionFunctions() {
   if (bases_begin() == bases_end()) {
     // If root class, all conversions are visible.
     Set = &data().Conversions.get(Ctx);
   } else {
     Set = &data().VisibleConversions.get(Ctx);
     // If visible conversion list is not evaluated, evaluate it.
     if (!data().ComputedVisibleConversions) {
       CollectVisibleConversions(Ctx, this, *Set);
-      data().ComputedVisibleConversions = true;
+      data().ComputedVisibleConversions = 1;
     }
   }
   return llvm::make_range(Set->begin(), Set->end());
 }
 
 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
   // This operation is O(N) but extremely rare.  Sema only uses it to
   // remove UsingShadowDecls in a class that were followed by a direct
for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
         assert(SO->second.size() > 0 && 
                "All virtual functions have overridding virtual functions");
         
         // C++ [class.abstract]p4:
         //   A class is abstract if it contains or inherits at least one
         //   pure virtual function for which the final overrider is pure
         //   virtual.
         if (SO->second.front().Method->isPure()) {
-          data().Abstract = true;
+          data().Abstract = 1;
           Done = true;
           break;
         }
       }
     }
   }
   
   // Set access bits correctly on the directly-declared conversions.

lib/AST/DeclObjC.cpp

 
 Stmt *ObjCMethodDecl::getBody() const {
   return Body.get(getASTContext().getExternalSource());
 }
 
 void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
   assert(PrevMethod);
   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
-  IsRedeclaration = true;
-  PrevMethod->HasRedeclaration = true;
+  IsRedeclaration = 1;
+  PrevMethod->HasRedeclaration = 1;
 }
 
 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
                                          ArrayRef<ParmVarDecl*> Params,
                                          ArrayRef<SourceLocation> SelLocs) {
   ParamsAndSelLocs = nullptr;
   NumParams = Params.size();
   if (Params.empty() && SelLocs.empty())

lib/AST/DeclPrinter.cpp

   }
   
   Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy);
   Out << ')';
 }
 
 void DeclPrinter::PrintObjCTypeParams(ObjCTypeParamList *Params) {
   Out << "<";
-  unsigned First = true;
+  unsigned First = 1;
   for (auto *Param : *Params) {
     if (First) {
-      First = false;
+      First = 0;
     } else {
       Out << ", ";
     }
 
     switch (Param->getVariance()) {
     case ObjCTypeParamVariance::Invariant:
       break;
 
     case ObjCTypeParamVariance::Covariant:
       Out << "__covariant ";

lib/AST/DeclTemplate.cpp

 // TemplateParameterList Implementation
 //===----------------------------------------------------------------------===//
 
 TemplateParameterList::TemplateParameterList(SourceLocation TemplateLoc,
                                              SourceLocation LAngleLoc,
                                              ArrayRef<NamedDecl *> Params,
                                              SourceLocation RAngleLoc)
   : TemplateLoc(TemplateLoc), LAngleLoc(LAngleLoc), RAngleLoc(RAngleLoc),
-    NumParams(Params.size()), ContainsUnexpandedParameterPack(false) {
+    NumParams(Params.size()), ContainsUnexpandedParameterPack(0) {
   assert(this->NumParams == NumParams && "Too many template parameters");
   for (unsigned Idx = 0; Idx < NumParams; ++Idx) {
     NamedDecl *P = Params[Idx];
     begin()[Idx] = P;
 
     if (!P->isTemplateParameterPack()) {
       if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P))
         if (NTTP->getType()->containsUnexpandedParameterPack())
-          ContainsUnexpandedParameterPack = true;
+          ContainsUnexpandedParameterPack = 1;
 
       if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
         if (TTP->getTemplateParameters()->containsUnexpandedParameterPack())
-          ContainsUnexpandedParameterPack = true;
+          ContainsUnexpandedParameterPack = 1;
 
       // FIXME: If a default argument contains an unexpanded parameter pack, the
       // template parameter list does too.
     }
   }
 }
 
 TemplateParameterList *TemplateParameterList::Create(

lib/AST/DeclarationName.cpp

int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector: {
     Selector LHSSelector = LHS.getObjCSelector();
     Selector RHSSelector = RHS.getObjCSelector();
     unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
     for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
       switch (LHSSelector.getNameForSlot(I).compare(
                                                RHSSelector.getNameForSlot(I))) {
-      case -1: return true;
-      case 1: return false;
+      case -1: return 1;
+      case 1: return 0;
       default: break;
       }
     }
 
     return compareInt(LN, RN);
   }
   
   case DeclarationName::CXXConstructorName:
if (Policy.SuppressTemplateArgsInCXXConstructors) {
     if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
       OS << *InjTy->getDecl();
       return;
     }
   }
   if (!Policy.LangOpts.CPlusPlus) {
     // Passed policy is the default one from operator <<, use a C++ policy.
     LangOptions LO;
-    LO.CPlusPlus = true;
+    LO.CPlusPlus = 1;
     ClassType.print(OS, PrintingPolicy(LO));
   } else {
     ClassType.print(OS, Policy);
   }
 }
 
 void DeclarationName::print(raw_ostream &OS, const PrintingPolicy &Policy) {
   DeclarationName &N = *this;
case DeclarationName::CXXConversionFunctionName: {
     QualType Type = N.getCXXNameType();
     if (const RecordType *Rec = Type->getAs<RecordType>()) {
       OS << *Rec->getDecl();
       return;
     }
     if (!Policy.LangOpts.CPlusPlus) {
       // Passed policy is the default one from operator <<, use a C++ policy.
       LangOptions LO;
-      LO.CPlusPlus = true;
-      LO.Bool = true;
+      LO.CPlusPlus = 1;
+      LO.Bool = 1;
       Type.print(OS, PrintingPolicy(LO));
     } else {
       Type.print(OS, Policy);
     }
     return;
   }
   case DeclarationName::CXXUsingDirective:
     OS << "<using-directive>";
void DeclarationNameInfo::printName(raw_ostream &OS) const {
   case DeclarationName::CXXDestructorName:
   case DeclarationName::CXXConversionFunctionName:
     if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo) {
       if (Name.getNameKind() == DeclarationName::CXXDestructorName)
         OS << '~';
       else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
         OS << "operator ";
       LangOptions LO;
-      LO.CPlusPlus = true;
-      LO.Bool = true;
+      LO.CPlusPlus = 1;
+      LO.Bool = 1;
       OS << TInfo->getType().getAsString(PrintingPolicy(LO));
     } else
       OS << Name;
     return;
   }
   llvm_unreachable("Unexpected declaration name kind");
 }
 

lib/AST/Expr.cpp

computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent,
                            ValueDependent, InstantiationDependent);
 
   ExprBits.TypeDependent |= TypeDependent;
   ExprBits.ValueDependent |= ValueDependent;
   ExprBits.InstantiationDependent |= InstantiationDependent;
 
   // Is the declaration a parameter pack?
   if (getDecl()->isParameterPack())
-    ExprBits.ContainsUnexpandedParameterPack = true;
+    ExprBits.ContainsUnexpandedParameterPack = 1;
 }
 
 DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc,
                          ValueDecl *D, bool RefersToEnclosingVariableOrCapture,
                          const DeclarationNameInfo &NameInfo,
                          NamedDecl *FoundD,
                          const TemplateArgumentListInfo *TemplateArgs,
                          QualType T, ExprValueKind VK)
   : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
     D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
   DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
   if (QualifierLoc) {
     new (getTrailingObjects<NestedNameSpecifierLoc>())
         NestedNameSpecifierLoc(QualifierLoc);
     auto *NNS = QualifierLoc.getNestedNameSpecifier();
     if (NNS->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (NNS->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
   }
   DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
   if (FoundD)
     *getTrailingObjects<NamedDecl *>() = FoundD;
   DeclRefExprBits.HasTemplateKWAndArgsInfo
     = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
   DeclRefExprBits.RefersToEnclosingVariableOrCapture =
       RefersToEnclosingVariableOrCapture;
FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
   setSemantics(V.getSemantics());
   FloatingLiteralBits.IsExact = isexact;
   setValue(C, V);
 }
 
 FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty)
   : Expr(FloatingLiteralClass, Empty) {
   setRawSemantics(IEEEhalf);
-  FloatingLiteralBits.IsExact = false;
+  FloatingLiteralBits.IsExact = 0;
 }
 
 FloatingLiteral *
 FloatingLiteral::Create(const ASTContext &C, const llvm::APFloat &V,
                         bool isexact, QualType Type, SourceLocation L) {
   return new (C) FloatingLiteral(C, V, isexact, Type, L);
 }
 
CallExpr::CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
   : Expr(SC, Empty), SubExprs(nullptr), NumArgs(0) {
   // FIXME: Why do we allocate this?
   SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]();
   CallExprBits.NumPreArgs = NumPreArgs;
 }
 
 void CallExpr::updateDependenciesFromArg(Expr *Arg) {
   if (Arg->isTypeDependent())
-    ExprBits.TypeDependent = true;
+    ExprBits.TypeDependent = 1;
   if (Arg->isValueDependent())
-    ExprBits.ValueDependent = true;
+    ExprBits.ValueDependent = 1;
   if (Arg->isInstantiationDependent())
-    ExprBits.InstantiationDependent = true;
+    ExprBits.InstantiationDependent = 1;
   if (Arg->containsUnexpandedParameterPack())
-    ExprBits.ContainsUnexpandedParameterPack = true;
+    ExprBits.ContainsUnexpandedParameterPack = 1;
 }
 
 Decl *CallExpr::getCalleeDecl() {
   Expr *CEE = getCallee()->IgnoreParenImpCasts();
     
   while (SubstNonTypeTemplateParmExpr *NTTP
                                 = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
     CEE = NTTP->getReplacement()->IgnoreParenCasts();
: Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
     NumComps(comps.size()), NumExprs(exprs.size())
 {
   for (unsigned i = 0; i != comps.size(); ++i) {
     setComponent(i, comps[i]);
   }
   
   for (unsigned i = 0; i != exprs.size(); ++i) {
     if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (exprs[i]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     setIndexExpr(i, exprs[i]);
   }
 }
 
 IdentifierInfo *OffsetOfNode::getFieldName() const {
   assert(getKind() == Field || getKind() == Identifier);
   if (getKind() == Field)
     return getField()->getIdentifier();
   
   return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
 }
 
 UnaryExprOrTypeTraitExpr::UnaryExprOrTypeTraitExpr(
     UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType,
     SourceLocation op, SourceLocation rp)
     : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
            false, // Never type-dependent (C++ [temp.dep.expr]p3).
            // Value-dependent if the argument is type-dependent.
            E->isTypeDependent(), E->isInstantiationDependent(),
            E->containsUnexpandedParameterPack()),
       OpLoc(op), RParenLoc(rp) {
   UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
-  UnaryExprOrTypeTraitExprBits.IsType = false;
+  UnaryExprOrTypeTraitExprBits.IsType = 0;
   Argument.Ex = E;
 
   // Check to see if we are in the situation where alignof(decl) should be
   // dependent because decl's alignment is dependent.
   if (ExprKind == UETT_AlignOf) {
     if (!isValueDependent() || !isInstantiationDependent()) {
       E = E->IgnoreParens();
 
InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
   : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
          false, false),
     InitExprs(C, initExprs.size()),
     LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(nullptr, true)
 {
   sawArrayRangeDesignator(false);
   for (unsigned I = 0; I != initExprs.size(); ++I) {
     if (initExprs[I]->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (initExprs[I]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (initExprs[I]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (initExprs[I]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
   }
       
   InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());
 }
 
 void InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) {
   if (NumInits > InitExprs.size())
     InitExprs.reserve(C, NumInits);
: Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
           Type->isDependentType(), Type->isDependentType(),
           Type->isInstantiationDependentType(),
           Type->containsUnexpandedParameterPack()),
      BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size())
 {
   SubExprs = new (C) Stmt*[args.size()];
   for (unsigned i = 0; i != args.size(); i++) {
     if (args[i]->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (args[i]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (args[i]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (args[i]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SubExprs[i] = args[i];
   }
 }
 
 void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
   if (SubExprs) C.Deallocate(SubExprs);
 
DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty,
   unsigned IndexIdx = 0;
   for (unsigned I = 0; I != NumDesignators; ++I) {
     this->Designators[I] = Designators[I];
 
     if (this->Designators[I].isArrayDesignator()) {
       // Compute type- and value-dependence.
       Expr *Index = IndexExprs[IndexIdx];
       if (Index->isTypeDependent() || Index->isValueDependent())
-        ExprBits.TypeDependent = ExprBits.ValueDependent = true;
+        ExprBits.TypeDependent = ExprBits.ValueDependent = 1;
       if (Index->isInstantiationDependent())
-        ExprBits.InstantiationDependent = true;
+        ExprBits.InstantiationDependent = 1;
       // Propagate unexpanded parameter packs.
       if (Index->containsUnexpandedParameterPack())
-        ExprBits.ContainsUnexpandedParameterPack = true;
+        ExprBits.ContainsUnexpandedParameterPack = 1;
 
       // Copy the index expressions into permanent storage.
       *Child++ = IndexExprs[IndexIdx++];
     } else if (this->Designators[I].isArrayRangeDesignator()) {
       // Compute type- and value-dependence.
       Expr *Start = IndexExprs[IndexIdx];
       Expr *End = IndexExprs[IndexIdx + 1];
       if (Start->isTypeDependent() || Start->isValueDependent() ||
           End->isTypeDependent() || End->isValueDependent()) {
-        ExprBits.TypeDependent = ExprBits.ValueDependent = true;
-        ExprBits.InstantiationDependent = true;
+        ExprBits.TypeDependent = ExprBits.ValueDependent = 1;
+        ExprBits.InstantiationDependent = 1;
       } else if (Start->isInstantiationDependent() || 
                  End->isInstantiationDependent()) {
-        ExprBits.InstantiationDependent = true;
+        ExprBits.InstantiationDependent = 1;
       }
                  
       // Propagate unexpanded parameter packs.
       if (Start->containsUnexpandedParameterPack() ||
           End->containsUnexpandedParameterPack())
-        ExprBits.ContainsUnexpandedParameterPack = true;
+        ExprBits.ContainsUnexpandedParameterPack = 1;
 
       // Copy the start/end expressions into permanent storage.
       *Child++ = IndexExprs[IndexIdx++];
       *Child++ = IndexExprs[IndexIdx++];
     }
   }
 
   assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions");
ParenListExpr::ParenListExpr(const ASTContext& C, SourceLocation lparenloc,
                              ArrayRef<Expr*> exprs,
                              SourceLocation rparenloc)
   : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary,
          false, false, false, false),
     NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) {
   Exprs = new (C) Stmt*[exprs.size()];
   for (unsigned i = 0; i != exprs.size(); ++i) {
     if (exprs[i]->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (exprs[i]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (exprs[i]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (exprs[i]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     Exprs[i] = exprs[i];
   }
 }
 
 const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
   if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
     e = ewc->getSubExpr();
PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK,
   PseudoObjectExprBits.NumSubExprs = semantics.size() + 1;
   PseudoObjectExprBits.ResultIndex = resultIndex + 1;
 
   for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
     Expr *E = (i == 0 ? syntax : semantics[i-1]);
     getSubExprsBuffer()[i] = E;
 
     if (E->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (E->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (E->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (E->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     if (isa<OpaqueValueExpr>(E))
       assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != nullptr &&
              "opaque-value semantic expressions for pseudo-object "
              "operations must have sources");
   }
 }
 
AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args,
                        QualType t, AtomicOp op, SourceLocation RP)
   : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary,
          false, false, false, false),
     NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op)
 {
   assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
   for (unsigned i = 0; i != args.size(); i++) {
     if (args[i]->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (args[i]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (args[i]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (args[i]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SubExprs[i] = args[i];
   }
 }
 
 unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) {
   switch (Op) {
   case AO__c11_atomic_init:

lib/AST/ExprCXX.cpp

CXXNewExpr::CXXNewExpr(const ASTContext &C, bool globalNew,
   assert((initializer != nullptr || initializationStyle == NoInit) &&
          "Only NoInit can have no initializer.");
   StoredInitializationStyle = initializer ? initializationStyle + 1 : 0;
   AllocateArgsArray(C, arraySize != nullptr, placementArgs.size(),
                     initializer != nullptr);
   unsigned i = 0;
   if (Array) {
     if (arraySize->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     
     if (arraySize->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SubExprs[i++] = arraySize;
   }
 
   if (initializer) {
     if (initializer->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
 
     if (initializer->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SubExprs[i++] = initializer;
   }
 
   for (unsigned j = 0; j != placementArgs.size(); ++j) {
     if (placementArgs[j]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (placementArgs[j]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SubExprs[i++] = placementArgs[j];
   }
 
   switch (getInitializationStyle()) {
   case CallInit:
     this->Range.setEnd(DirectInitRange.getEnd()); break;
   case ListInit:
: Expr(K, C.OverloadTy, VK_LValue, OK_Ordinary, KnownDependent,
     HasTemplateKWAndArgsInfo(TemplateArgs != nullptr ||
                              TemplateKWLoc.isValid()) {
   NumResults = End - Begin;
   if (NumResults) {
     // Determine whether this expression is type-dependent.
     for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I) {
       if ((*I)->getDeclContext()->isDependentContext() ||
           isa<UnresolvedUsingValueDecl>(*I)) {
-        ExprBits.TypeDependent = true;
-        ExprBits.ValueDependent = true;
-        ExprBits.InstantiationDependent = true;
+        ExprBits.TypeDependent = 1;
+        ExprBits.ValueDependent = 1;
+        ExprBits.InstantiationDependent = 1;
       }
     }
 
     Results = static_cast<DeclAccessPair *>(
                                 C.Allocate(sizeof(DeclAccessPair) * NumResults, 
                                            llvm::alignOf<DeclAccessPair>()));
     memcpy(Results, Begin.I, NumResults * sizeof(DeclAccessPair));
   }
 
   // If we have explicit template arguments, check for dependent
   // template arguments and whether they contain any unexpanded pack
   // expansions.
   if (TemplateArgs) {
     bool Dependent = false;
     bool InstantiationDependent = false;
     bool ContainsUnexpandedParameterPack = false;
     getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(
         TemplateKWLoc, *TemplateArgs, getTrailingTemplateArgumentLoc(),
         Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
 
     if (Dependent) {
-      ExprBits.TypeDependent = true;
-      ExprBits.ValueDependent = true;
+      ExprBits.TypeDependent = 1;
+      ExprBits.ValueDependent = 1;
     }
     if (InstantiationDependent)
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (ContainsUnexpandedParameterPack)
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
   } else if (TemplateKWLoc.isValid()) {
     getTrailingASTTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
   }
 
   if (isTypeDependent())
     setType(C.DependentTy);
 }
 

 {
   if (NumArgs) {
     Args = new (C) Stmt*[args.size()];
     
     for (unsigned i = 0; i != args.size(); ++i) {
       assert(args[i] && "NULL argument in CXXConstructExpr");
 
       if (args[i]->isValueDependent())
-        ExprBits.ValueDependent = true;
+        ExprBits.ValueDependent = 1;
       if (args[i]->isInstantiationDependent())
-        ExprBits.InstantiationDependent = true;
+        ExprBits.InstantiationDependent = 1;
       if (args[i]->containsUnexpandedParameterPack())
-        ExprBits.ContainsUnexpandedParameterPack = true;
+        ExprBits.ContainsUnexpandedParameterPack = 1;
   
       Args[i] = args[i];
     }
   }
 }
 
 LambdaCapture::OpaqueCapturedEntity LambdaCapture::ThisSentinel;
 LambdaCapture::OpaqueCapturedEntity LambdaCapture::VLASentinel;
: Expr(CXXUnresolvedConstructExprClass,
          Type->getType()->containsUnexpandedParameterPack()),
     Type(Type),
     LParenLoc(LParenLoc),
     RParenLoc(RParenLoc),
     NumArgs(Args.size()) {
   Expr **StoredArgs = getTrailingObjects<Expr *>();
   for (unsigned I = 0; I != Args.size(); ++I) {
     if (Args[I]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     StoredArgs[I] = Args[I];
   }
 }
 
 CXXUnresolvedConstructExpr *
 CXXUnresolvedConstructExpr::Create(const ASTContext &C,
                                    TypeSourceInfo *Type,
CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
   if (TemplateArgs) {
     bool Dependent = true;
     bool InstantiationDependent = true;
     bool ContainsUnexpandedParameterPack = false;
     getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
         TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
         Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
     if (ContainsUnexpandedParameterPack)
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
   } else if (TemplateKWLoc.isValid()) {
     getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
         TemplateKWLoc);
   }
 }
 
 CXXDependentScopeMemberExpr *
 CXXDependentScopeMemberExpr::Create(const ASTContext &C,

lib/AST/ExprObjC.cpp

 ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, QualType T,
                                    ObjCMethodDecl *Method, SourceRange SR)
     : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
            false, false),
       NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) {
   Expr **SaveElements = getElements();
   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
     if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (Elements[I]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (Elements[I]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     SaveElements[I] = Elements[I];
   }
 }
 
 ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C,
                                            ArrayRef<Expr *> Elements,
                                            QualType T, ObjCMethodDecl *Method,
: Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
       NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
       DictWithObjectsMethod(method) {
   KeyValuePair *KeyValues = getTrailingObjects<KeyValuePair>();
   ExpansionData *Expansions =
       HasPackExpansions ? getTrailingObjects<ExpansionData>() : nullptr;
   for (unsigned I = 0; I < NumElements; I++) {
     if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() ||
         VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (VK[I].Key->isInstantiationDependent() ||
         VK[I].Value->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (VK[I].EllipsisLoc.isInvalid() &&
         (VK[I].Key->containsUnexpandedParameterPack() ||
          VK[I].Value->containsUnexpandedParameterPack()))
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     KeyValues[I].Key = VK[I].Key;
     KeyValues[I].Value = VK[I].Value;
     if (Expansions) {
       Expansions[I].EllipsisLoc = VK[I].EllipsisLoc;
       if (VK[I].NumExpansions)
         Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1;
       else
ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation RBracLoc, bool isImplicit)
     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
            /*TypeDependent=*/false, /*ValueDependent=*/false,
            /*InstantiationDependent=*/false,
            /*ContainsUnexpandedParameterPack=*/false),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
       Kind(IsInstanceSuper ? SuperInstance : SuperClass),
-      HasMethod(Method != nullptr), IsDelegateInitCall(false),
+      HasMethod(Method != nullptr), IsDelegateInitCall(0),
       IsImplicit(isImplicit), SuperLoc(SuperLoc), LBracLoc(LBracLoc),
       RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(SuperType.getAsOpaquePtr());
 }
 
 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation LBracLoc,
                                  TypeSourceInfo *Receiver, Selector Sel,
                                  ArrayRef<SourceLocation> SelLocs,
                                  SelectorLocationsKind SelLocsK,
                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
                                  SourceLocation RBracLoc, bool isImplicit)
     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
            T->isDependentType(), T->isInstantiationDependentType(),
            T->containsUnexpandedParameterPack()),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
-      Kind(Class), HasMethod(Method != nullptr), IsDelegateInitCall(false),
+      Kind(Class), HasMethod(Method != nullptr), IsDelegateInitCall(0),
       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(Receiver);
 }
 
 ObjCMessageExpr::ObjCMessageExpr(QualType T, ExprValueKind VK,
                                  SourceLocation LBracLoc, Expr *Receiver,
                                  Selector Sel, ArrayRef<SourceLocation> SelLocs,
                                  SelectorLocationsKind SelLocsK,
                                  ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
                                  SourceLocation RBracLoc, bool isImplicit)
     : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
            Receiver->isTypeDependent(), Receiver->isTypeDependent(),
            Receiver->isInstantiationDependent(),
            Receiver->containsUnexpandedParameterPack()),
       SelectorOrMethod(
           reinterpret_cast<uintptr_t>(Method ? Method : Sel.getAsOpaquePtr())),
-      Kind(Instance), HasMethod(Method != nullptr), IsDelegateInitCall(false),
+      Kind(Instance), HasMethod(Method != nullptr), IsDelegateInitCall(0),
       IsImplicit(isImplicit), LBracLoc(LBracLoc), RBracLoc(RBracLoc) {
   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
   setReceiverPointer(Receiver);
 }
 
 void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
                                          ArrayRef<SourceLocation> SelLocs,
                                          SelectorLocationsKind SelLocsK) {
   setNumArgs(Args.size());
   Expr **MyArgs = getArgs();
   for (unsigned I = 0; I != Args.size(); ++I) {
     if (Args[I]->isTypeDependent())
-      ExprBits.TypeDependent = true;
+      ExprBits.TypeDependent = 1;
     if (Args[I]->isValueDependent())
-      ExprBits.ValueDependent = true;
+      ExprBits.ValueDependent = 1;
     if (Args[I]->isInstantiationDependent())
-      ExprBits.InstantiationDependent = true;
+      ExprBits.InstantiationDependent = 1;
     if (Args[I]->containsUnexpandedParameterPack())
-      ExprBits.ContainsUnexpandedParameterPack = true;
+      ExprBits.ContainsUnexpandedParameterPack = 1;
 
     MyArgs[I] = Args[I];
   }
 
   SelLocsKind = SelLocsK;
   if (!isImplicit()) {
     if (SelLocsK == SelLoc_NonStandard)
       std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());

lib/AST/RecordLayoutBuilder.cpp

protected:
 
   /// Valid if UseExternalLayout is true.
   ExternalLayout External;
 
   ItaniumRecordLayoutBuilder(const ASTContext &Context,
                              EmptySubobjectMap *EmptySubobjects)
       : Context(Context), EmptySubobjects(EmptySubobjects), Size(0),
         Alignment(CharUnits::One()), UnpackedAlignment(CharUnits::One()),
-        UseExternalLayout(false), InferAlignment(false), Packed(false),
-        IsUnion(false), IsMac68kAlign(false), IsMsStruct(false),
+        UseExternalLayout(0), InferAlignment(0), Packed(0),
+        IsUnion(0), IsMac68kAlign(0), IsMsStruct(0),
         UnfilledBitsInLastUnit(0), LastBitfieldTypeSize(0),
         MaxFieldAlignment(CharUnits::Zero()), DataSize(0),
         NonVirtualSize(CharUnits::Zero()),
         NonVirtualAlignment(CharUnits::One()), PrimaryBase(nullptr),
         PrimaryBaseIsVirtual(false), HasOwnVFPtr(false),
         FirstNearlyEmptyVBase(nullptr) {}
 
   void Layout(const RecordDecl *D);
if (!HasExternalLayout) {
     bool Allowed = EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset);
     (void)Allowed;
     assert(Allowed && "Base subobject externally placed at overlapping offset");
 
     if (InferAlignment && Offset < getDataSize().alignTo(BaseAlign)) {
       // The externally-supplied base offset is before the base offset we
       // computed. Assume that the structure is packed.
       Alignment = CharUnits::One();
-      InferAlignment = false;
+      InferAlignment = 0;
     }
   }
   
   if (!Base->Class->isEmpty()) {
     // Update the data size.
     setDataSize(Offset + Layout.getNonVirtualSize());
 
     setSize(std::max(getSize(), getDataSize()));
if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct) {
     MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
   }
 
   // mac68k alignment supersedes maximum field alignment and attribute aligned,
   // and forces all structures to have 2-byte alignment. The IBM docs on it
   // allude to additional (more complicated) semantics, especially with regard
   // to bit-fields, but gcc appears not to follow that.
   if (D->hasAttr<AlignMac68kAttr>()) {
-    IsMac68kAlign = true;
+    IsMac68kAlign = 1;
     MaxFieldAlignment = CharUnits::fromQuantity(2);
     Alignment = CharUnits::fromQuantity(2);
   } else {
     if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>())
       MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment());
 
     if (unsigned MaxAlign = D->getMaxAlignment())
       UpdateAlignment(Context.toCharUnitsFromBits(MaxAlign));
   }
   
   // If there is an external AST source, ask it for the various offsets.
   if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
     if (ExternalASTSource *Source = Context.getExternalSource()) {
       UseExternalLayout = Source->layoutRecordType(
           RD, External.Size, External.Align, External.FieldOffsets,
           External.BaseOffsets, External.VirtualBaseOffsets);
 
       // Update based on external alignment.
       if (UseExternalLayout) {
         if (External.Align > 0) {
           Alignment = Context.toCharUnitsFromBits(External.Align);
         } else {
           // The external source didn't have alignment information; infer it.
-          InferAlignment = true;
+          InferAlignment = 1;
         }
       }
     }
 }
 
 void ItaniumRecordLayoutBuilder::Layout(const RecordDecl *D) {
   InitializeLayout(D);
   LayoutFields(D);
uint64_t RoundedSize =
       llvm::alignTo(getSizeInBits(), Context.toBits(Alignment));
 
   if (UseExternalLayout) {
     // If we're inferring alignment, and the external size is smaller than
     // our size after we've rounded up to alignment, conservatively set the
     // alignment to 1.
     if (InferAlignment && External.Size < RoundedSize) {
       Alignment = CharUnits::One();
-      InferAlignment = false;
+      InferAlignment = 0;
     }
     setSize(External.Size);
     return;
   }
 
   // Set the size to the final size.
   setSize(RoundedSize);
 

 ItaniumRecordLayoutBuilder::updateExternalFieldOffset(const FieldDecl *Field,
                                                       uint64_t ComputedOffset) {
   uint64_t ExternalFieldOffset = External.getExternalFieldOffset(Field);
 
   if (InferAlignment && ExternalFieldOffset < ComputedOffset) {
     // The externally-supplied field offset is before the field offset we
     // computed. Assume that the structure is packed.
     Alignment = CharUnits::One();
-    InferAlignment = false;
+    InferAlignment = 0;
   }
   
   // Use the externally-supplied field offset.
   return ExternalFieldOffset;
 }
 
 /// \brief Get diagnostic %select index for tag kind for
 /// field padding diagnostic message.

lib/AST/TemplateBase.cpp

void TemplateArgument::print(const PrintingPolicy &Policy,
                              raw_ostream &Out) const {
   switch (getKind()) {
   case Null:
     Out << "(no value)";
     break;
     
   case Type: {
     PrintingPolicy SubPolicy(Policy);
-    SubPolicy.SuppressStrongLifetime = true;
+    SubPolicy.SuppressStrongLifetime = 1;
     getAsType().print(Out, SubPolicy);
     break;
   }
     
   case Declaration: {
     NamedDecl *ND = cast<NamedDecl>(getAsDecl());
     Out << '&';
     if (ND->getDeclName()) {
case Pack:
     }
     Out << ">";
     break;        
   }
 }
 
 void TemplateArgument::dump(raw_ostream &Out) const {
   LangOptions LO; // FIXME! see also TemplateName::dump().
-  LO.CPlusPlus = true;
-  LO.Bool = true;
+  LO.CPlusPlus = 1;
+  LO.Bool = 1;
   print(PrintingPolicy(LO), Out);
 }
 
 LLVM_DUMP_METHOD void TemplateArgument::dump() const { dump(llvm::errs()); }
 
 //===----------------------------------------------------------------------===//
 // TemplateArgumentLoc Implementation
 //===----------------------------------------------------------------------===//
const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
 
   case TemplateArgument::Expression: {
     // This shouldn't actually ever happen, so it's okay that we're
     // regurgitating an expression here.
     // FIXME: We're guessing at LangOptions!
     SmallString<32> Str;
     llvm::raw_svector_ostream OS(Str);
     LangOptions LangOpts;
-    LangOpts.CPlusPlus = true;
+    LangOpts.CPlusPlus = 1;
     PrintingPolicy Policy(LangOpts);
     Arg.getAsExpr()->printPretty(OS, nullptr, Policy);
     return DB << OS.str();
   }
       
   case TemplateArgument::Pack: {
     // FIXME: We're guessing at LangOptions!
     SmallString<32> Str;
     llvm::raw_svector_ostream OS(Str);
     LangOptions LangOpts;
-    LangOpts.CPlusPlus = true;
+    LangOpts.CPlusPlus = 1;
     PrintingPolicy Policy(LangOpts);
     Arg.print(Policy, OS);
     return DB << OS.str();
   }
   }
 
   llvm_unreachable("Invalid TemplateArgument Kind!");
 }

lib/AST/TemplateName.cpp

TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
   }
 }
 
 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
                                            TemplateName N) {
   std::string NameStr;
   raw_string_ostream OS(NameStr);
   LangOptions LO;
-  LO.CPlusPlus = true;
-  LO.Bool = true;
+  LO.CPlusPlus = 1;
+  LO.Bool = 1;
   OS << '\'';
   N.print(OS, PrintingPolicy(LO));
   OS << '\'';
   OS.flush();
   return DB << NameStr;
 }
 
 void TemplateName::dump(raw_ostream &OS) const {
   LangOptions LO;  // FIXME!
-  LO.CPlusPlus = true;
-  LO.Bool = true;
+  LO.CPlusPlus = 1;
+  LO.Bool = 1;
   print(OS, PrintingPolicy(LO));
 }
 
 LLVM_DUMP_METHOD void TemplateName::dump() const {
   dump(llvm::errs());
 }

lib/AST/Type.cpp

     // If the cache is valid, we're okay.
     if (T->TypeBits.isCacheValid()) return;
 
     // If this type is non-canonical, ask its canonical type for the
     // relevant information.
     if (!T->isCanonicalUnqualified()) {
       const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
       ensure(CT);
-      T->TypeBits.CacheValid = true;
+      T->TypeBits.CacheValid = 1;
       T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
       T->TypeBits.CachedLocalOrUnnamed = CT->TypeBits.CachedLocalOrUnnamed;
       return;
     }
 
     // Compute the cached properties and then set the cache.
     CachedProperties Result = computeCachedProperties(T);
-    T->TypeBits.CacheValid = true;
+    T->TypeBits.CacheValid = 1;
     T->TypeBits.CachedLinkage = Result.getLinkage();
     T->TypeBits.CachedLocalOrUnnamed = Result.hasLocalOrUnnamedType();
   }
 };
 }
 
 // Instantiate the friend template at a private class.  In a
 // reasonable implementation, these symbols will be internal.

lib/AST/TypePrinter.cpp

namespace {
   class IncludeStrongLifetimeRAII {
     PrintingPolicy &Policy;
     bool Old;
     
   public:
     explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy) 
       : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
         if (!Policy.SuppressLifetimeQualifiers)
-          Policy.SuppressStrongLifetime = false;
+          Policy.SuppressStrongLifetime = 0;
     }
     
     ~IncludeStrongLifetimeRAII() {
       Policy.SuppressStrongLifetime = Old;
     }
   };
 
   class ParamPolicyRAII {

lib/Analysis/CFG.cpp

 
   raw_ostream &OS;
   StmtPrinterHelper* Helper;
   PrintingPolicy Policy;
 public:
   CFGBlockTerminatorPrint(raw_ostream &os, StmtPrinterHelper* helper,
                           const PrintingPolicy &Policy)
     : OS(os), Helper(helper), Policy(Policy) {
-    this->Policy.IncludeNewlines = false;
+    this->Policy.IncludeNewlines = 0;
   }
 
   void VisitIfStmt(IfStmt *I) {
     OS << "if ";
     if (Stmt *C = I->getCond())
       C->printPretty(OS, Helper, Policy);
   }
 

lib/Basic/Diagnostic.cpp

case DiagnosticsEngine::ak_attr:
       break;
     case DiagnosticsEngine::ak_qualtype_pair:
       // Create a struct with all the info needed for printing.
       TemplateDiffTypes TDT;
       TDT.FromType = getRawArg(ArgNo);
       TDT.ToType = getRawArg(ArgNo2);
       TDT.ElideType = getDiags()->ElideType;
       TDT.ShowColors = getDiags()->ShowColors;
-      TDT.TemplateDiffUsed = false;
+      TDT.TemplateDiffUsed = 0;
       intptr_t val = reinterpret_cast<intptr_t>(&TDT);
 
       const char *ArgumentEnd = Argument + ArgumentLen;
       const char *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
 
       // Print the tree.  If this diagnostic already has a tree, skip the
       // second tree.
       if (getDiags()->PrintTemplateTree && Tree.empty()) {
-        TDT.PrintFromType = true;
-        TDT.PrintTree = true;
+        TDT.PrintFromType = 1;
+        TDT.PrintTree = 1;
         getDiags()->ConvertArgToString(Kind, val,
                                        StringRef(Modifier, ModifierLen),
                                        StringRef(Argument, ArgumentLen),
                                        FormattedArgs,
                                        Tree, QualTypeVals);
         // If there is no tree information, fall back to regular printing.
         if (!Tree.empty()) {
           FormatDiagnostic(Pipe + 1, ArgumentEnd, OutStr);
           break;
         }
       }
 
       // Non-tree printing, also the fall-back when tree printing fails.
       // The fall-back is triggered when the types compared are not templates.
       const char *FirstDollar = ScanFormat(Argument, ArgumentEnd, '$');
       const char *SecondDollar = ScanFormat(FirstDollar + 1, ArgumentEnd, '$');
 
       // Append before text
       FormatDiagnostic(Argument, FirstDollar, OutStr);
 
       // Append first type
-      TDT.PrintTree = false;
-      TDT.PrintFromType = true;
+      TDT.PrintTree = 0;
+      TDT.PrintFromType = 1;
       getDiags()->ConvertArgToString(Kind, val,
                                      StringRef(Modifier, ModifierLen),
                                      StringRef(Argument, ArgumentLen),
                                      FormattedArgs,
                                      OutStr, QualTypeVals);
       if (!TDT.TemplateDiffUsed)
         FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
                                                TDT.FromType));
 
       // Append middle text
       FormatDiagnostic(FirstDollar + 1, SecondDollar, OutStr);
 
       // Append second type
-      TDT.PrintFromType = false;
+      TDT.PrintFromType = 0;
       getDiags()->ConvertArgToString(Kind, val,
                                      StringRef(Modifier, ModifierLen),
                                      StringRef(Argument, ArgumentLen),
                                      FormattedArgs,
                                      OutStr, QualTypeVals);
       if (!TDT.TemplateDiffUsed)
         FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
                                                TDT.ToType));

lib/Basic/Module.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace clang;
 
 Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
                bool IsFramework, bool IsExplicit, unsigned VisibilityID)
     : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent), Directory(),
       Umbrella(), Signature(0), ASTFile(nullptr), VisibilityID(VisibilityID),
-      IsMissingRequirement(false), HasIncompatibleModuleFile(false),
-      IsAvailable(true), IsFromModuleFile(false), IsFramework(IsFramework),
-      IsExplicit(IsExplicit), IsSystem(false), IsExternC(false),
-      IsInferred(false), InferSubmodules(false), InferExplicitSubmodules(false),
-      InferExportWildcard(false), ConfigMacrosExhaustive(false),
+      IsMissingRequirement(0), HasIncompatibleModuleFile(0),
+      IsAvailable(1), IsFromModuleFile(0), IsFramework(IsFramework),
+      IsExplicit(IsExplicit), IsSystem(0), IsExternC(0),
+      IsInferred(0), InferSubmodules(0), InferExplicitSubmodules(0),
+      InferExportWildcard(0), ConfigMacrosExhaustive(0),
       NameVisibility(Hidden) {
   if (Parent) {
     if (!Parent->isAvailable())
-      IsAvailable = false;
+      IsAvailable = 0;
     if (Parent->IsSystem)
-      IsSystem = true;
+      IsSystem = 1;
     if (Parent->IsExternC)
-      IsExternC = true;
+      IsExternC = 1;
     IsMissingRequirement = Parent->IsMissingRequirement;
     
     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
     Parent->SubModules.push_back(this);
   }
 }
 
 Module::~Module() {
void Module::markUnavailable(bool MissingRequirement) {
   Stack.push_back(this);
   while (!Stack.empty()) {
     Module *Current = Stack.back();
     Stack.pop_back();
 
     if (!needUpdate(Current))
       continue;
 
-    Current->IsAvailable = false;
+    Current->IsAvailable = 0;
     Current->IsMissingRequirement |= MissingRequirement;
     for (submodule_iterator Sub = Current->submodule_begin(),
                          SubEnd = Current->submodule_end();
          Sub != SubEnd; ++Sub) {
       if (needUpdate(*Sub))
         Stack.push_back(*Sub);
     }
   }

lib/Basic/SourceManager.cpp

 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          llvm::MemoryBuffer *Buffer,
                                          bool DoNotFree) {
   const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
 
   const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(Buffer, DoNotFree);
-  const_cast<SrcMgr::ContentCache *>(IR)->BufferOverridden = true;
+  const_cast<SrcMgr::ContentCache *>(IR)->BufferOverridden = 1;
 
   getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          const FileEntry *NewFile) {
   assert(SourceFile->getSize() == NewFile->getSize() &&
          "Different sizes, use the FileManager to create a virtual file with "
void SourceManager::disableFileContentsOverride(const FileEntry *File) {
 
   assert(OverriddenFilesInfo);
   OverriddenFilesInfo->OverriddenFiles.erase(File);
   OverriddenFilesInfo->OverriddenFilesWithBuffer.erase(File);
 }
 
 void SourceManager::setFileIsTransient(const FileEntry *File) {
   const SrcMgr::ContentCache *CC = getOrCreateContentCache(File);
-  const_cast<SrcMgr::ContentCache *>(CC)->IsTransient = true;
+  const_cast<SrcMgr::ContentCache *>(CC)->IsTransient = 1;
 }
 
 StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
   bool MyInvalid = false;
   const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
   if (!SLoc.isFile() || MyInvalid) {
     if (Invalid) 
       *Invalid = true;

lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   IntPtrType = SignedLong;
   WCharType = SignedInt;
   WIntType = SignedInt;
   Char16Type = UnsignedShort;
   Char32Type = UnsignedInt;
   Int64Type = SignedLongLong;
   SigAtomicType = SignedInt;
   ProcessIDType = SignedInt;
-  UseSignedCharForObjCBool = true;
-  UseBitFieldTypeAlignment = true;
-  UseZeroLengthBitfieldAlignment = false;
-  UseExplicitBitFieldAlignment = true;
+  UseSignedCharForObjCBool = 1;
+  UseBitFieldTypeAlignment = 1;
+  UseZeroLengthBitfieldAlignment = 0;
+  UseExplicitBitFieldAlignment = 1;
   ZeroLengthBitfieldBoundary = 0;
   HalfFormat = &llvm::APFloat::IEEEhalf;
   FloatFormat = &llvm::APFloat::IEEEsingle;
   DoubleFormat = &llvm::APFloat::IEEEdouble;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble;
   MCountName = "mcount";
   RegParmMax = 0;
   SSERegParmMax = 0;
-  HasAlignMac68kSupport = false;
-  HasBuiltinMSVaList = false;
+  HasAlignMac68kSupport = 0;
+  HasBuiltinMSVaList = 0;
 
   // Default to no types using fpret.
   RealTypeUsesObjCFPRet = 0;
 
   // Default to not using fp2ret for __Complex long double
-  ComplexLongDoubleUsesFP2Ret = false;
+  ComplexLongDoubleUsesFP2Ret = 0;
 
   // Set the C++ ABI based on the triple.
   TheCXXABI.set(Triple.isKnownWindowsMSVCEnvironment()
                     ? TargetCXXABI::Microsoft
                     : TargetCXXABI::GenericItanium);
 
   // Default to an empty address space map.
   AddrSpaceMap = &DefaultAddrSpaceMap;
bool TargetInfo::isTypeSigned(IntType T) {
   };
 }
 
 /// adjust - Set forced language options.
 /// Apply changes to the target information with respect to certain
 /// language options which change the target configuration.
 void TargetInfo::adjust(const LangOptions &Opts) {
   if (Opts.NoBitFieldTypeAlign)
-    UseBitFieldTypeAlignment = false;
+    UseBitFieldTypeAlignment = 0;
   if (Opts.ShortWChar)
     WCharType = UnsignedShort;
 
   if (Opts.OpenCL) {
     // OpenCL C requires specific widths for types, irrespective of
     // what these normally are for the target.
     // We also define long long and long double here, although the
     // OpenCL standard only mentions these as "reserved".

lib/Basic/Targets.cpp

   PS4OSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->WCharType = this->UnsignedShort;
 
     // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
     this->MaxTLSAlign = 256;
 
     // On PS4, do not honor explicit bit field alignment,
     // as in "__attribute__((aligned(2))) int b : 1;".
-    this->UseExplicitBitFieldAlignment = false;
+    this->UseExplicitBitFieldAlignment = 0;
 
     switch (Triple.getArch()) {
     default:
     case llvm::Triple::x86_64:
       this->MCountName = ".mcount";
       break;
     }
   }

   }
 };
 
 class DarwinPPC32TargetInfo :
   public DarwinTargetInfo<PPC32TargetInfo> {
 public:
   DarwinPPC32TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
-    HasAlignMac68kSupport = true;
+    HasAlignMac68kSupport = 1;
     BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
     PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
     LongLongAlign = 32;
     SuitableAlign = 128;
     resetDataLayout("E-m:o-p:32:32-f64:32:64-n32");
   }
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::CharPtrBuiltinVaList;
   }
 };
 
 class DarwinPPC64TargetInfo :
   public DarwinTargetInfo<PPC64TargetInfo> {
 public:
   DarwinPPC64TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
-    HasAlignMac68kSupport = true;
+    HasAlignMac68kSupport = 1;
     SuitableAlign = 128;
     resetDataLayout("E-m:o-i64:64-n32:64");
   }
 };
 
 static const unsigned NVPTXAddrSpaceMap[] = {
     1, // opencl_global
     3, // opencl_local

       : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     SuitableAlign = 128;
     MaxVectorAlign = 256;
     // The watchOS simulator uses the builtin bool type for Objective-C.
     llvm::Triple T = llvm::Triple(Triple);
     if (T.isWatchOS())
-      UseSignedCharForObjCBool = false;
+      UseSignedCharForObjCBool = 0;
     SizeType = UnsignedLong;
     IntPtrType = SignedLong;
     resetDataLayout("e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128");
-    HasAlignMac68kSupport = true;
+    HasAlignMac68kSupport = 1;
   }
 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override {
     if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
                                                                   Diags))
       return false;
     // We now know the features we have: we can decide how to align vectors.

                         ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
                         : IsWinCOFF ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
                                     : "e-m:e-i64:64-f80:128-n8:16:32:64-S128");
 
     // Use fpret only for long double.
     RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
 
     // Use fp2ret for _Complex long double.
-    ComplexLongDoubleUsesFP2Ret = true;
+    ComplexLongDoubleUsesFP2Ret = 1;
 
     // Make __builtin_ms_va_list available.
-    HasBuiltinMSVaList = true;
+    HasBuiltinMSVaList = 1;
 
     // x86-64 has atomics up to 16 bytes.
     MaxAtomicPromoteWidth = 128;
     MaxAtomicInlineWidth = 128;
   }
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::X86_64ABIBuiltinVaList;
   }

 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
 public:
   DarwinX86_64TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
     Int64Type = SignedLongLong;
     // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
     llvm::Triple T = llvm::Triple(Triple);
     if (T.isiOS())
-      UseSignedCharForObjCBool = false;
+      UseSignedCharForObjCBool = 0;
     resetDataLayout("e-m:o-i64:64-f80:128-n8:16:32:64-S128");
   }
 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override {
     if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
                                                                   Diags))
       return false;

     HW_FP_SP = (1 << 2), /// single (32-bit)
     HW_FP_DP = (1 << 3), /// double (64-bit)
   };
   uint32_t HW_FP;
 
   static const Builtin::Info BuiltinInfo[];
 
   void setABIAAPCS() {
-    IsAAPCS = true;
+    IsAAPCS = 1;
 
     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
     const llvm::Triple &T = getTriple();
 
     // size_t is unsigned long on MachO-derived environments, NetBSD and Bitrig.
     if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
         T.getOS() == llvm::Triple::Bitrig)
       SizeType = UnsignedLong;

       break;
     case llvm::Triple::Linux:
     default:
       // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
       WCharType = UnsignedInt;
       break;
     }
 
-    UseBitFieldTypeAlignment = true;
+    UseBitFieldTypeAlignment = 1;
 
     ZeroLengthBitfieldBoundary = 0;
 
     // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
     // so set preferred for small types to 32.
     if (T.isOSBinFormatMachO()) {
       resetDataLayout(BigEndian
                           ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"

     }
 
     // FIXME: Enumerated types are variable width in straight AAPCS.
   }
 
   void setABIAPCS(bool IsAAPCS16) {
     const llvm::Triple &T = getTriple();
 
-    IsAAPCS = false;
+    IsAAPCS = 0;
 
     if (IsAAPCS16)
       DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
     else
       DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
 
     // size_t is unsigned int on FreeBSD.
     if (T.getOS() == llvm::Triple::FreeBSD)
       SizeType = UnsignedInt;
     else
       SizeType = UnsignedLong;
 
     // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
     WCharType = SignedInt;
 
     // Do not respect the alignment of bit-field types when laying out
     // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
-    UseBitFieldTypeAlignment = false;
+    UseBitFieldTypeAlignment = 0;
 
     /// gcc forces the alignment to 4 bytes, regardless of the type of the
     /// zero length bitfield.  This corresponds to EMPTY_FIELD_BOUNDARY in
     /// gcc.
     ZeroLengthBitfieldBoundary = 32;
 
     if (T.isOSBinFormatMachO() && IsAAPCS16) {
       assert(!BigEndian && "AAPCS16 does not support big-endian");

     default:
       return "";
     }
   }
 
 public:
   ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
       : TargetInfo(Triple), FPMath(FP_Default),
-        IsAAPCS(true), LDREX(0), HW_FP(0) {
+        IsAAPCS(1), LDREX(0), HW_FP(0) {
     BigEndian = IsBigEndian;
 
     switch (getTriple().getOS()) {
     case llvm::Triple::NetBSD:
       PtrDiffType = SignedLong;
       break;
     default:
       PtrDiffType = SignedInt;

 
     // ARM has atomics up to 8 bytes
     setAtomic();
 
     // Do force alignment of members that follow zero length bitfields.  If
     // the alignment of the zero-length bitfield is greater than the member
     // that follows it, `bar', `bar' will be aligned as the  type of the
     // zero length bitfield.
-    UseZeroLengthBitfieldAlignment = true;
+    UseZeroLengthBitfieldAlignment = 1;
   }
 
   StringRef getABI() const override { return ABI; }
 
   bool setABI(const std::string &Name) override {
     ABI = Name;
 
     // The defaults (above) are for AAPCS, check if we need to change them.

 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override {
     FPU = 0;
     CRC = 0;
     Crypto = 0;
     DSP = 0;
     Unaligned = 1;
-    SoftFloat = SoftFloatABI = false;
+    SoftFloat = SoftFloatABI = 0;
     HWDiv = 0;
 
     // This does not diagnose illegal cases like having both
     // "+vfpv2" and "+vfpv3" or having "+neon" and "+fp-only-sp".
     uint32_t HW_FP_remove = 0;
     for (const auto &Feature : Features) {
       if (Feature == "+soft-float") {
-        SoftFloat = true;
+        SoftFloat = 1;
       } else if (Feature == "+soft-float-abi") {
-        SoftFloatABI = true;
+        SoftFloatABI = 1;
       } else if (Feature == "+vfp2") {
         FPU |= VFP2FPU;
         HW_FP |= HW_FP_SP | HW_FP_DP;
       } else if (Feature == "+vfp3") {
         FPU |= VFP3FPU;
         HW_FP |= HW_FP_SP | HW_FP_DP;
       } else if (Feature == "+vfp4") {
         FPU |= VFP4FPU;

   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
   }
 
 public:
   DarwinARMTargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
-    HasAlignMac68kSupport = true;
+    HasAlignMac68kSupport = 1;
     // iOS always has 64-bit atomic instructions.
     // FIXME: This should be based off of the target features in
     // ARMleTargetInfo.
     MaxAtomicInlineWidth = 64;
 
     if (Triple.isWatchABI()) {
       // Darwin on iOS uses a variant of the ARM C++ ABI.
       TheCXXABI.set(TargetCXXABI::WatchOS);
 
       // The 32-bit ABI is silent on what ptrdiff_t should be, but given that
       // size_t is long, it's a bit weird for it to be int.
       PtrDiffType = SignedLong;
 
       // BOOL should be a real boolean on the new ABI
-      UseSignedCharForObjCBool = false;
+      UseSignedCharForObjCBool = 0;
     } else
       TheCXXABI.set(TargetCXXABI::iOS);
   }
 };
 
 class AArch64TargetInfo : public TargetInfo {
   virtual void setDataLayout() = 0;
   static const TargetInfo::GCCRegAlias GCCRegAliases[];

     // specifiers.
     NoAsmVariants = true;
 
     // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
     // contributes to the alignment of the containing aggregate in the same way
     // a plain (non bit-field) member of that type would, without exception for
     // zero-sized or anonymous bit-fields."
     assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
-    UseZeroLengthBitfieldAlignment = true;
+    UseZeroLengthBitfieldAlignment = 1;
 
     // AArch64 targets default to using the ARM C++ ABI.
     TheCXXABI.set(TargetCXXABI::GenericAArch64);
   }
 
   StringRef getABI() const override { return ABI; }
   bool setABI(const std::string &Name) override {
     if (Name != "aapcs" && Name != "darwinpcs")

     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
   }
 
 public:
   DarwinAArch64TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
     Int64Type = SignedLongLong;
     WCharType = SignedInt;
-    UseSignedCharForObjCBool = false;
+    UseSignedCharForObjCBool = 0;
 
     LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
 
     TheCXXABI.set(TargetCXXABI::iOS64);
   }
 
   BuiltinVaListKind getBuiltinVaListKind() const override {

     IntPtrType  = SignedInt;
 
     // {} in inline assembly are packet specifiers, not assembly variant
     // specifiers.
     NoAsmVariants = true;
 
     LargeArrayMinWidth = 64;
     LargeArrayAlign = 64;
-    UseBitFieldTypeAlignment = true;
+    UseBitFieldTypeAlignment = 1;
     ZeroLengthBitfieldBoundary = 32;
     HasHVX = HasHVXDouble = false;
   }
 
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return llvm::makeArrayRef(BuiltinInfo,
                          clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin);
   }

     LongLongAlign = 32;
     SuitableAlign = 32;
     DoubleAlign = LongDoubleAlign = 32;
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
     IntPtrType = SignedInt;
     WCharType = UnsignedChar;
     WIntType = UnsignedInt;
-    UseZeroLengthBitfieldAlignment = true;
+    UseZeroLengthBitfieldAlignment = 1;
     resetDataLayout("e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
                     "-f64:32-a:0:32-n32");
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     Builder.defineMacro("__XS1B__");
   }
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {

lib/CodeGen/CGAtomic.cpp

 AddDirectArgument(CodeGenFunction &CGF, CallArgList &Args,
                   bool UseOptimizedLibcall, llvm::Value *Val, QualType ValTy,
                   SourceLocation Loc, CharUnits SizeInChars) {
   if (UseOptimizedLibcall) {
     // Load value and pass it to the function directly.
     CharUnits Align = CGF.getContext().getTypeAlignInChars(ValTy);
     int64_t SizeInBits = CGF.getContext().toBits(SizeInChars);
     ValTy =
-        CGF.getContext().getIntTypeForBitwidth(SizeInBits, /*Signed=*/false);
+        CGF.getContext().getIntTypeForBitwidth(SizeInBits, /*Signed=*/0);
     llvm::Type *IPtrTy = llvm::IntegerType::get(CGF.getLLVMContext(),
                                                 SizeInBits)->getPointerTo();
     Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
     Val = CGF.EmitLoadOfScalar(Ptr, false,
                                CGF.getContext().getPointerType(ValTy),
                                Loc);
     // Coerce the value into an appropriately sized integer type.
     Args.add(RValue::get(Val), ValTy);
if (UseLibcall) {
     if (UseOptimizedLibcall)
       LibCallName += "_" + llvm::utostr(Size);
     // By default, assume we return a value of the atomic type.
     if (!HaveRetTy) {
       if (UseOptimizedLibcall) {
         // Value is returned directly.
         // The function returns an appropriately sized integer type.
         RetTy = getContext().getIntTypeForBitwidth(
-            getContext().toBits(sizeChars), /*Signed=*/false);
+            getContext().toBits(sizeChars), /*Signed=*/0);
       } else {
         // Value is returned through parameter before the order.
         RetTy = getContext().VoidTy;
         Args.add(RValue::get(EmitCastToVoidPtr(Dest.getPointer())),
                  getContext().VoidPtrTy);
       }
     }
     // order is always the last parameter

lib/CodeGen/CGBuiltin.cpp

   }
   // Count leading zeros
   case PPC::BI__builtin_altivec_vclzb:
   case PPC::BI__builtin_altivec_vclzh:
   case PPC::BI__builtin_altivec_vclzw:
   case PPC::BI__builtin_altivec_vclzd: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
   // Copy sign
   case PPC::BI__builtin_vsx_xvcpsgnsp:
   case PPC::BI__builtin_vsx_xvcpsgndp: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));

   }
 
   case SystemZ::BI__builtin_s390_vclzb:
   case SystemZ::BI__builtin_s390_vclzh:
   case SystemZ::BI__builtin_s390_vclzf:
   case SystemZ::BI__builtin_s390_vclzg: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
 
   case SystemZ::BI__builtin_s390_vctzb:
   case SystemZ::BI__builtin_s390_vctzh:
   case SystemZ::BI__builtin_s390_vctzf:
   case SystemZ::BI__builtin_s390_vctzg: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
 
   case SystemZ::BI__builtin_s390_vfsqdb: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);

lib/CodeGen/CGObjC.cpp

 /// Pick an implementation strategy for the given property synthesis.
 PropertyImplStrategy::PropertyImplStrategy(CodeGenModule &CGM,
                                      const ObjCPropertyImplDecl *propImpl) {
   const ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
   ObjCPropertyDecl::SetterKind setterKind = prop->getSetterKind();
 
   IsCopy = (setterKind == ObjCPropertyDecl::Copy);
   IsAtomic = prop->isAtomic();
-  HasStrong = false; // doesn't matter here.
+  HasStrong = 0; // doesn't matter here.
 
   // Evaluate the ivar's size and alignment.
   ObjCIvarDecl *ivar = propImpl->getPropertyIvarDecl();
   QualType ivarType = ivar->getType();
   std::tie(IvarSize, IvarAlignment) =
       CGM.getContext().getTypeInfoInChars(ivarType);
 
   // If we have a copy property, we always have to use getProperty/setProperty.

lib/CodeGen/CGOpenMPRuntime.cpp

                                              SourceLocation Loc) {
   if (auto *OMPRegionInfo =
           dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo))
     if (OMPRegionInfo->getThreadIDVariable())
       return OMPRegionInfo->getThreadIDVariableLValue(CGF).getAddress();
 
   auto ThreadID = getThreadID(CGF, Loc);
   auto Int32Ty =
-      CGF.getContext().getIntTypeForBitwidth(/*DestWidth*/ 32, /*Signed*/ true);
+      CGF.getContext().getIntTypeForBitwidth(/*DestWidth*/ 32, /*Signed*/ 1);
   auto ThreadIDTemp = CGF.CreateMemTemp(Int32Ty, /*Name*/ ".threadid_temp.");
   CGF.EmitStoreOfScalar(ThreadID,
                         CGF.MakeAddrLValue(ThreadIDTemp, Int32Ty));
 
   return ThreadIDTemp;
 }
 
 llvm::Constant *

       CGF.Builder.CreateConstArrayGEP(Array, Index, CGF.getPointerSize());
   llvm::Value *Ptr = CGF.Builder.CreateLoad(PtrAddr);
 
   Address Addr = Address(Ptr, CGF.getContext().getDeclAlign(Var));
   Addr = CGF.Builder.CreateElementBitCast(
       Addr, CGF.ConvertTypeForMem(Var->getType()));
   return Addr;
 }
 
 static llvm::Value *emitCopyprivateCopyFunction(
     CodeGenModule &CGM, llvm::Type *ArgsType,
     ArrayRef<const Expr *> CopyprivateVars, ArrayRef<const Expr *> DestExprs,
     ArrayRef<const Expr *> SrcExprs, ArrayRef<const Expr *> AssignmentOps) {
   auto &C = CGM.getContext();
   // void copy_func(void *LHSArg, void *RHSArg);
   FunctionArgList Args;
   ImplicitParamDecl LHSArg(C, /*DC=*/nullptr, SourceLocation(), /*Id=*/nullptr,

       IL.getPointer(), // &isLastIter
       LB.getPointer(), // &Lower
       UB.getPointer(), // &Upper
       ST.getPointer()  // &Stride
   };
   llvm::Value *Call =
       CGF.EmitRuntimeCall(createDispatchNextFunction(IVSize, IVSigned), Args);
   return CGF.EmitScalarConversion(
-      Call, CGF.getContext().getIntTypeForBitwidth(32, /* Signed */ true),
+      Call, CGF.getContext().getIntTypeForBitwidth(32, /* Signed */ 1),
       CGF.getContext().BoolTy, Loc);
 }
 
 void CGOpenMPRuntime::emitNumThreadsClause(CodeGenFunction &CGF,
                                            llvm::Value *NumThreads,
                                            SourceLocation Loc) {
   if (!CGF.HaveInsertPoint())
     return;

   //   __tgt_offload_entry  *EntriesEnd;     // End of the table with all the
   //                                         // entries (non inclusive).
   // };
   if (TgtBinaryDescriptorQTy.isNull()) {
     ASTContext &C = CGM.getContext();
     auto *RD = C.buildImplicitRecord("__tgt_bin_desc");
     RD->startDefinition();
     addFieldToRecordDecl(
-        C, RD, C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/true));
+        C, RD, C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtDeviceImageQTy()));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtOffloadEntryQTy()));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtOffloadEntryQTy()));
     RD->completeDefinition();
     TgtBinaryDescriptorQTy = C.getRecordType(RD);
   }
   return TgtBinaryDescriptorQTy;
 }

   Address DependenciesArray = Address::invalid();
   unsigned NumDependencies = Dependences.size();
   if (NumDependencies) {
     // Dependence kind for RTL.
     enum RTLDependenceKindTy { DepIn = 0x01, DepInOut = 0x3 };
     enum RTLDependInfoFieldsTy { BaseAddr, Len, Flags };
     RecordDecl *KmpDependInfoRD;
     QualType FlagsTy =
-        C.getIntTypeForBitwidth(C.getTypeSize(C.BoolTy), /*Signed=*/false);
+        C.getIntTypeForBitwidth(C.getTypeSize(C.BoolTy), /*Signed=*/0);
     llvm::Type *LLVMFlagsTy = CGF.ConvertTypeForMem(FlagsTy);
     if (KmpDependInfoTy.isNull()) {
       KmpDependInfoRD = C.buildImplicitRecord("kmp_depend_info");
       KmpDependInfoRD->startDefinition();
       addFieldToRecordDecl(C, KmpDependInfoRD, C.getIntPtrType());
       addFieldToRecordDecl(C, KmpDependInfoRD, C.getSizeType());
       addFieldToRecordDecl(C, KmpDependInfoRD, FlagsTy);
       KmpDependInfoRD->completeDefinition();

     BasePointers.push_back(BasePointer);
     Pointers.push_back(Pointer);
     Sizes.push_back(Size);
     MapTypes.push_back(MapType);
   }
 
   // Keep track on whether the host function has to be executed.
   auto OffloadErrorQType =
-      Ctx.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/true);
+      Ctx.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
   auto OffloadError = CGF.MakeAddrLValue(
       CGF.CreateMemTemp(OffloadErrorQType, ".run_host_version"),
       OffloadErrorQType);
   CGF.EmitStoreOfScalar(llvm::Constant::getNullValue(CGM.Int32Ty),
                         OffloadError);
 
   // Fill up the pointer arrays and transfer execution to the device.
   auto &&ThenGen = [&Ctx, &BasePointers, &Pointers, &Sizes, &MapTypes,

lib/CodeGen/ObjectFilePCHContainerOperations.cpp

PCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName,
         HeaderSearchOpts(CI.getHeaderSearchOpts()),
         PreprocessorOpts(CI.getPreprocessorOpts()),
         TargetOpts(CI.getTargetOpts()), LangOpts(CI.getLangOpts()), OS(OS),
         Buffer(Buffer) {
     // The debug info output isn't affected by CodeModel and
     // ThreadModel, but the backend expects them to be nonempty.
     CodeGenOpts.CodeModel = "default";
     CodeGenOpts.ThreadModel = "single";
-    CodeGenOpts.DebugTypeExtRefs = true;
+    CodeGenOpts.DebugTypeExtRefs = 1;
     CodeGenOpts.setDebugInfo(codegenoptions::FullDebugInfo);
   }
 
   ~PCHContainerGenerator() override = default;
 
   void Initialize(ASTContext &Context) override {
     assert(!Ctx && "initialized multiple times");
 

lib/Driver/Driver.cpp

Driver::Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple,
                IntrusiveRefCntPtr<vfs::FileSystem> VFS)
     : Opts(createDriverOptTable()), Diags(Diags), VFS(VFS), Mode(GCCMode),
       SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone), LTOMode(LTOK_None),
       ClangExecutable(ClangExecutable),
       SysRoot(DEFAULT_SYSROOT), UseStdLib(true),
       DefaultTargetTriple(DefaultTargetTriple),
       DriverTitle("clang LLVM compiler"), CCPrintOptionsFilename(nullptr),
       CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr),
-      CCCPrintBindings(false), CCPrintHeaders(false), CCLogDiagnostics(false),
-      CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true),
-      CCCUsePCH(true), SuppressMissingInputWarning(false) {
+      CCCPrintBindings(0), CCPrintHeaders(0), CCLogDiagnostics(0),
+      CCGenDiagnostics(0), CCCGenericGCCName(""), CheckInputsExist(1),
+      CCCUsePCH(1), SuppressMissingInputWarning(false) {
 
   // Provide a sane fallback if no VFS is specified.
   if (!this->VFS)
     this->VFS = vfs::getRealFileSystem();
 
   Name = llvm::sys::path::filename(ClangExecutable);
   Dir = llvm::sys::path::parent_path(ClangExecutable);
   InstalledDir = Dir; // Provide a sensible default installed dir.
void Driver::generateCompilationDiagnostics(Compilation &C,
   PrintVersion(C, llvm::errs());
 
   Diag(clang::diag::note_drv_command_failed_diag_msg)
       << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
          "crash backtrace, preprocessed source, and associated run script.";
 
   // Suppress driver output and emit preprocessor output to temp file.
   Mode = CPPMode;
-  CCGenDiagnostics = true;
+  CCGenDiagnostics = 1;
 
   // Save the original job command(s).
   Command Cmd = FailingCommand;
 
   // Keep track of whether we produce any errors while trying to produce
   // preprocessed sources.
   DiagnosticErrorTrap Trap(Diags);
 

lib/Driver/Tools.cpp

       // Make sure that the double entry was not already specified.
       // The float entry will be checked below.
       if (OptionStrings[ValBase.str() + 'd']) {
         D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
         return;
       }
     }
 
-    if (OptionIter->second == true) {
+    if (OptionIter->second == 1) {
       // Duplicate option specified.
       D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val;
       return;
     }
 
     // Mark the matched option as found. Do not allow duplicate specifiers.
     OptionIter->second = true;
 
     // If the precision was not specified, also mark the double entry as found.
     if (ValBase.back() != 'f' && ValBase.back() != 'd')
       OptionStrings[ValBase.str() + 'd'] = true;
 
     // Build the output string.

lib/Frontend/ASTUnit.cpp

: Reader(nullptr), HadModuleLoaderFatalFailure(false),
     NumStoredDiagnosticsFromDriver(0),
     PreambleRebuildCounter(0),
     NumWarningsInPreamble(0),
     ShouldCacheCodeCompletionResults(false),
     IncludeBriefCommentsInCodeCompletion(false), UserFilesAreVolatile(false),
     CompletionCacheTopLevelHashValue(0),
     PreambleTopLevelHashValue(0),
     CurrentTopLevelHashValue(0),
-    UnsafeToFree(false) { 
+    UnsafeToFree(0) { 
   if (getenv("LIBCLANG_OBJTRACKING"))
     fprintf(stderr, "+++ %u translation units\n", ++ActiveASTUnitObjects);
 }
 
 ASTUnit::~ASTUnit() {
   // If we loaded from an AST file, balance out the BeginSourceFile call.
   if (MainFileIsAST && getDiagnostics().getClient()) {
     getDiagnostics().getClient()->EndSourceFile();
ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
   llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
     ASTUnitCleanup(OwnAST.get());
   llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
     llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
     DiagCleanup(Diags.get());
 
   // We'll manage file buffers ourselves.
   CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
-  CI->getFrontendOpts().DisableFree = false;
+  CI->getFrontendOpts().DisableFree = 0;
   ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
 
   // Create the compiler instance to use for building the AST.
   std::unique_ptr<CompilerInstance> Clang(
       new CompilerInstance(PCHContainerOps));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>

 bool ASTUnit::LoadFromCompilerInvocation(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     unsigned PrecompilePreambleAfterNParses) {
   if (!Invocation)
     return true;
   
   // We'll manage file buffers ourselves.
   Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
-  Invocation->getFrontendOpts().DisableFree = false;
+  Invocation->getFrontendOpts().DisableFree = 0;
   ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
 
   std::unique_ptr<llvm::MemoryBuffer> OverrideMainBuffer;
   if (PrecompilePreambleAfterNParses > 0) {
     PreambleRebuildCounter = PrecompilePreambleAfterNParses;
     OverrideMainBuffer =
         getMainBufferWithPrecompiledPreamble(PCHContainerOps, *Invocation);
   }
void ASTUnit::CodeComplete(
   FrontendOpts.CodeCompletionAt.FileName = File;
   FrontendOpts.CodeCompletionAt.Line = Line;
   FrontendOpts.CodeCompletionAt.Column = Column;
 
   // Set the language options appropriately.
   LangOpts = *CCInvocation->getLangOpts();
 
   // Spell-checking and warnings are wasteful during code-completion.
-  LangOpts.SpellChecking = false;
-  CCInvocation->getDiagnosticOpts().IgnoreWarnings = true;
+  LangOpts.SpellChecking = 0;
+  CCInvocation->getDiagnosticOpts().IgnoreWarnings = 1;
 
   std::unique_ptr<CompilerInstance> Clang(
       new CompilerInstance(PCHContainerOps));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
     CICleanup(Clang.get());
 
if (OverrideMainBuffer) {
     OwnedBuffers.push_back(OverrideMainBuffer.release());
   } else {
     PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
     PreprocessorOpts.PrecompiledPreambleBytes.second = false;
   }
 
   // Disable the preprocessing record if modules are not enabled.
   if (!Clang->getLangOpts().Modules)
-    PreprocessorOpts.DetailedRecord = false;
+    PreprocessorOpts.DetailedRecord = 0;
 
   std::unique_ptr<SyntaxOnlyAction> Act;
   Act.reset(new SyntaxOnlyAction);
   if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0])) {
     Act->Execute();
     Act->EndSourceFile();
   }
 }

lib/Frontend/CompilerInstance.cpp

if (!ImportingPPOpts.FailedModules)
     ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
   PPOpts.FailedModules = ImportingPPOpts.FailedModules;
 
   // If there is a module map file, build the module using the module map.
   // Set up the inputs/outputs so that we build the module from its umbrella
   // header.
   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
   FrontendOpts.OutputFile = ModuleFileName.str();
-  FrontendOpts.DisableFree = false;
-  FrontendOpts.GenerateGlobalModuleIndex = false;
-  FrontendOpts.BuildingImplicitModule = true;
+  FrontendOpts.DisableFree = 0;
+  FrontendOpts.GenerateGlobalModuleIndex = 0;
+  FrontendOpts.BuildingImplicitModule = 1;
   FrontendOpts.Inputs.clear();
   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
 
   // Don't free the remapped file buffers; they are owned by our caller.
   PPOpts.RetainRemappedFileBuffers = true;
     
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
   assert(ImportingInstance.getInvocation().getModuleHash() ==
struct ReadModuleNames : ASTReaderListener {
     }
 
     void markAllUnavailable() {
       for (auto *II : LoadedModules) {
         if (Module *M = CI.getPreprocessor()
                             .getHeaderSearchInfo()
                             .getModuleMap()
                             .findModule(II->getName()))
-          M->HasIncompatibleModuleFile = true;
+          M->HasIncompatibleModuleFile = 1;
       }
       LoadedModules.clear();
     }
   };
 
   // If we don't already have an ASTReader, create one now.
   if (!ModuleManager)
     createModuleManager();

lib/Frontend/CompilerInvocation.cpp

Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
                                  /*Default=*/true);
   Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
   Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
   Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
 
   llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
 
   // Default behavior is to not to show note include stacks.
-  Opts.ShowNoteIncludeStack = false;
+  Opts.ShowNoteIncludeStack = 0;
   if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
                                OPT_fno_diagnostics_show_note_include_stack))
     if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
-      Opts.ShowNoteIncludeStack = true;
+      Opts.ShowNoteIncludeStack = 1;
 
   StringRef ShowOverloads =
     Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
   if (ShowOverloads == "best")
     Opts.setShowOverloads(Ovl_Best);
   else if (ShowOverloads == "all")
     Opts.setShowOverloads(Ovl_All);
   else {
bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
   StringRef Format =
     Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
   if (Format == "clang")
     Opts.setFormat(DiagnosticOptions::Clang);
   else if (Format == "msvc")
     Opts.setFormat(DiagnosticOptions::MSVC);
   else if (Format == "msvc-fallback") {
     Opts.setFormat(DiagnosticOptions::MSVC);
-    Opts.CLFallbackMode = true;
+    Opts.CLFallbackMode = 1;
   } else if (Format == "vi")
     Opts.setFormat(DiagnosticOptions::Vi);
   else {
     Success = false;
     if (Diags)
       Diags->Report(diag::err_drv_invalid_value)
       << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
       << Format;

lib/Frontend/FrontendActions.cpp

if (std::error_code Err = collectModuleHeaderIncludes(
             LangOpts, FileMgr, ModMap, *Sub, Includes))
       return Err;
 
   return std::error_code();
 }
 
 bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI, 
                                                  StringRef Filename) {
-  CI.getLangOpts().CompilingModule = true;
+  CI.getLangOpts().CompilingModule = 1;
 
   // Find the module map file.
   const FileEntry *ModuleMap =
       CI.getFileManager().getFile(Filename, /*openFile*/true);
   if (!ModuleMap)  {
     CI.getDiagnostics().Report(diag::err_module_map_not_found)
       << Filename;
     return false;
if (MissingHeader.FileNameLoc.isValid()) {
         << Module->getFullModuleName()
         << Requirement.second << Requirement.first;
     }
 
     return false;
   }
 
   if (ModuleMapForUniquing && ModuleMapForUniquing != ModuleMap) {
-    Module->IsInferred = true;
+    Module->IsInferred = 1;
     HS.getModuleMap().setInferredModuleAllowedBy(Module, ModuleMapForUniquing);
   } else {
     ModuleMapForUniquing = ModuleMap;
   }
 
   FileManager &FileMgr = CI.getFileManager();
 
   // Collect the set of #includes we need to build the module.

lib/Index/CommentToXML.cpp

 };
 
 void getSourceTextOfDeclaration(const DeclInfo *ThisDecl,
                                 SmallVectorImpl<char> &Str) {
   ASTContext &Context = ThisDecl->CurrentDecl->getASTContext();
   const LangOptions &LangOpts = Context.getLangOpts();
   llvm::raw_svector_ostream OS(Str);
   PrintingPolicy PPolicy(LangOpts);
-  PPolicy.PolishForDeclaration = true;
-  PPolicy.TerseOutput = true;
+  PPolicy.PolishForDeclaration = 1;
+  PPolicy.TerseOutput = 1;
   ThisDecl->CurrentDecl->print(OS, PPolicy,
                                /*Indentation*/0, /*PrintInstantiation*/false);
 }
 
 void CommentASTToXMLConverter::formatTextOfDeclaration(
     const DeclInfo *DI, SmallString<128> &Declaration) {
   // Formatting API expects null terminated input string.
   StringRef StringDecl(Declaration.c_str(), Declaration.size());

lib/Index/IndexSymbol.cpp

 
 bool index::printSymbolName(const Decl *D, const LangOptions &LO,
                             raw_ostream &OS) {
   if (auto *ND = dyn_cast<NamedDecl>(D)) {
     PrintingPolicy Policy(LO);
     // Forward references can have different template argument names. Suppress
     // the template argument names in constructors to make their name more
     // stable.
-    Policy.SuppressTemplateArgsInCXXConstructors = true;
+    Policy.SuppressTemplateArgsInCXXConstructors = 1;
     DeclarationName DeclName = ND->getDeclName();
     if (DeclName.isEmpty())
       return true;
     DeclName.print(OS, Policy);
     return false;
   } else {
     return true;
   }

lib/Index/USRGeneration.cpp

if (FunctionTemplateDecl *FunTmpl = D->getDescribedFunctionTemplate()) {
     Out << "@FT@";
     VisitTemplateParameterList(FunTmpl->getTemplateParameters());
   } else
     Out << "@F@";
 
   PrintingPolicy Policy(Context->getLangOpts());
   // Forward references can have different template argument names. Suppress the
   // template argument names in constructors to make their USR more stable.
-  Policy.SuppressTemplateArgsInCXXConstructors = true;
+  Policy.SuppressTemplateArgsInCXXConstructors = 1;
   D->getDeclName().print(Out, Policy);
 
   ASTContext &Ctx = *Context;
   if ((!Ctx.getLangOpts().CPlusPlus || D->isExternC()) &&
       !D->hasAttr<OverloadableAttr>())
     return;
 
   if (const TemplateArgumentList *

lib/Lex/HeaderSearch.cpp

static void mergeHeaderFileInfo(HeaderFileInfo &HFI,
 
   if (!HFI.ControllingMacro && !HFI.ControllingMacroID) {
     HFI.ControllingMacro = OtherHFI.ControllingMacro;
     HFI.ControllingMacroID = OtherHFI.ControllingMacroID;
   }
 
   HFI.DirInfo = OtherHFI.DirInfo;
   HFI.External = (!HFI.IsValid || HFI.External);
-  HFI.IsValid = true;
+  HFI.IsValid = 1;
   HFI.IndexHeaderMapHeader = OtherHFI.IndexHeaderMapHeader;
 
   if (HFI.Framework.empty())
     HFI.Framework = OtherHFI.Framework;
 }
                                 
 /// getFileInfo - Return the HeaderFileInfo structure for the specified
 /// FileEntry.
 HeaderFileInfo &HeaderSearch::getFileInfo(const FileEntry *FE) {
   if (FE->getUID() >= FileInfo.size())
     FileInfo.resize(FE->getUID() + 1);
 
   HeaderFileInfo *HFI = &FileInfo[FE->getUID()];
   // FIXME: Use a generation count to check whether this is really up to date.
   if (ExternalSource && !HFI->Resolved) {
-    HFI->Resolved = true;
+    HFI->Resolved = 1;
     auto ExternalHFI = ExternalSource->GetHeaderFileInfo(FE);
 
     HFI = &FileInfo[FE->getUID()];
     if (ExternalHFI.External)
       mergeHeaderFileInfo(*HFI, ExternalHFI);
   }
 
-  HFI->IsValid = true;
+  HFI->IsValid = 1;
   // We have local information about this header file, so it's no longer
   // strictly external.
-  HFI->External = false;
+  HFI->External = 0;
   return *HFI;
 }
 
 const HeaderFileInfo *
 HeaderSearch::getExistingFileInfo(const FileEntry *FE,
                                   bool WantExternal) const {
   // If we have an external source, ensure we have the latest information.
   // FIXME: Use a generation count to check whether this is really up to date.
   HeaderFileInfo *HFI;
   if (ExternalSource) {
     if (FE->getUID() >= FileInfo.size()) {
       if (!WantExternal)
         return nullptr;
       FileInfo.resize(FE->getUID() + 1);
     }
 
     HFI = &FileInfo[FE->getUID()];
     if (!WantExternal && (!HFI->IsValid || HFI->External))
       return nullptr;
     if (!HFI->Resolved) {
-      HFI->Resolved = true;
+      HFI->Resolved = 1;
       auto ExternalHFI = ExternalSource->GetHeaderFileInfo(FE);
 
       HFI = &FileInfo[FE->getUID()];
       if (ExternalHFI.External)
         mergeHeaderFileInfo(*HFI, ExternalHFI);
     }
   } else if (FE->getUID() >= FileInfo.size()) {
     return nullptr;
bool HeaderSearch::ShouldEnterIncludeFile(Preprocessor &PP,
 
   // Get information about this file.
   HeaderFileInfo &FileInfo = getFileInfo(File);
 
   // If this is a #import directive, check that we have not already imported
   // this header.
   if (isImport) {
     // If this has already been imported, don't import it again.
-    FileInfo.isImport = true;
+    FileInfo.isImport = 1;
 
     // Has this already been #import'ed or #include'd?
     if (FileInfo.NumIncludes) return false;
   } else {
     // Otherwise, if this is a #include of a file that was previously #import'd
     // or if this is the second #include of a #pragma once file, ignore it.
     if (FileInfo.isImport)
       return false;

lib/Lex/Lexer.cpp

                             bool &TokAtPhysicalStartOfLine) {
   // If Line comments aren't explicitly enabled for this language, emit an
   // extension warning.
   if (!LangOpts.LineComment && !isLexingRawMode()) {
     Diag(BufferPtr, diag::ext_line_comment);
 
     // Mark them enabled so we only emit one warning for this translation
     // unit.
-    LangOpts.LineComment = true;
+    LangOpts.LineComment = 1;
   }
 
   // Scan over the body of the comment.  The common case, when scanning, is that
   // the comment contains normal ascii characters with nothing interesting in
   // them.  As such, optimize for this case with the inner loop.
   char C;
   do {
     C = *CurPtr;

lib/Lex/ModuleMap.cpp

 }
 
 ModuleMap::ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags,
                      const LangOptions &LangOpts, const TargetInfo *Target,
                      HeaderSearch &HeaderInfo)
     : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target),
       HeaderInfo(HeaderInfo), BuiltinIncludeDir(nullptr),
       SourceModule(nullptr), NumCreatedModules(0) {
-  MMapLangOpts.LineComment = true;
+  MMapLangOpts.LineComment = 1;
 }
 
 ModuleMap::~ModuleMap() {
   for (auto &M : Modules)
     delete M.getValue();
 }
 
 void ModuleMap::setTarget(const TargetInfo &Target) {
if (UmbrellaModule->InferSubmodules) {
       for (unsigned I = SkippedDirs.size(); I != 0; --I) {
         // Find or create the module that corresponds to this directory name.
         SmallString<32> NameBuf;
         StringRef Name = sanitizeFilenameAsIdentifier(
             llvm::sys::path::stem(SkippedDirs[I-1]->getName()), NameBuf);
         Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
                                     Explicit).first;
         InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
-        Result->IsInferred = true;
+        Result->IsInferred = 1;
 
         // Associate the module and the directory.
         UmbrellaDirs[SkippedDirs[I-1]] = Result;
 
         // If inferred submodules export everything they import, add a
         // wildcard to the set of exports.
         if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
           Result->Exports.push_back(Module::ExportDecl(nullptr, true));
       }
 
       // Infer a submodule with the same name as this header file.
       SmallString<32> NameBuf;
       StringRef Name = sanitizeFilenameAsIdentifier(
                          llvm::sys::path::stem(File->getName()), NameBuf);
       Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
                                   Explicit).first;
       InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
-      Result->IsInferred = true;
+      Result->IsInferred = 1;
       Result->addTopHeader(File);
 
       // If inferred submodules export everything they import, add a
       // wildcard to the set of exports.
       if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
         Result->Exports.push_back(Module::ExportDecl(nullptr, true));
     } else {
       // Record each of the directories we stepped through as being part of
Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
   // idea.
   if (!UmbrellaHeader)
     return nullptr;
 
   Module *Result = new Module(ModuleName, SourceLocation(), Parent,
                               /*IsFramework=*/true, /*IsExplicit=*/false,
                               NumCreatedModules++);
   InferredModuleAllowedBy[Result] = ModuleMapFile;
-  Result->IsInferred = true;
+  Result->IsInferred = 1;
   if (!Parent) {
     if (LangOpts.CurrentModule == ModuleName)
       SourceModule = Result;
     Modules[ModuleName] = Result;
   }
 
   Result->IsSystem |= Attrs.IsSystem;
   Result->IsExternC |= Attrs.IsExternC;
   Result->ConfigMacrosExhaustive |= Attrs.IsExhaustive;
   Result->Directory = FrameworkDir;
 
   // umbrella header "umbrella-header-name"
   //
   // The "Headers/" component of the name is implied because this is
   // a framework module.
   setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h");
   
   // export *
   Result->Exports.push_back(Module::ExportDecl(nullptr, true));
 
   // module * { export * }
-  Result->InferSubmodules = true;
-  Result->InferExportWildcard = true;
+  Result->InferSubmodules = 1;
+  Result->InferExportWildcard = 1;
   
   // Look for subframeworks.
   std::error_code EC;
   SmallString<128> SubframeworksDirName
     = StringRef(FrameworkDir->getName());
   llvm::sys::path::append(SubframeworksDirName, "Frameworks");
   llvm::sys::path::native(SubframeworksDirName);
   for (llvm::sys::fs::directory_iterator Dir(SubframeworksDirName, EC), DirEnd;
if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
     return;
   }
 
   // Start defining this module.
   ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework,
                                         Explicit).first;
   ActiveModule->DefinitionLoc = ModuleNameLoc;
   if (Attrs.IsSystem || IsSystem)
-    ActiveModule->IsSystem = true;
+    ActiveModule->IsSystem = 1;
   if (Attrs.IsExternC)
-    ActiveModule->IsExternC = true;
+    ActiveModule->IsExternC = 1;
   ActiveModule->Directory = Directory;
 
   bool Done = false;
   do {
     switch (Tok.Kind) {
     case MMToken::EndOfFile:
     case MMToken::RBrace:
       Done = true;
void ModuleMapParser::parseConfigMacros() {
   }
 
   // Parse the optional attributes.
   Attributes Attrs;
   if (parseOptionalAttributes(Attrs))
     return;
 
   if (Attrs.IsExhaustive && !ActiveModule->Parent) {
-    ActiveModule->ConfigMacrosExhaustive = true;
+    ActiveModule->ConfigMacrosExhaustive = 1;
   }
 
   // If we don't have an identifier, we're done.
   // FIXME: Support macros with the same name as a keyword here.
   if (!Tok.is(MMToken::Identifier))
     return;
 
   // Consume the first identifier.
void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) {
 
   // Parse optional attributes.
   Attributes Attrs;
   if (parseOptionalAttributes(Attrs))
     return;
 
   if (ActiveModule) {
     // Note that we have an inferred submodule.
-    ActiveModule->InferSubmodules = true;
+    ActiveModule->InferSubmodules = 1;
     ActiveModule->InferredSubmoduleLoc = StarLoc;
     ActiveModule->InferExplicitSubmodules = Explicit;
   } else {
     // We'll be inferring framework modules for this directory.
-    Map.InferredDirectories[Directory].InferModules = true;
+    Map.InferredDirectories[Directory].InferModules = 1;
     Map.InferredDirectories[Directory].Attrs = Attrs;
     Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile;
     // FIXME: Handle the 'framework' keyword.
   }
 
   // Parse the opening brace.
   if (!Tok.is(MMToken::LBrace)) {
     Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard);
case MMToken::ExportKeyword:
         Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
           << (ActiveModule != nullptr);
         consumeToken();
         break;
       }
 
       consumeToken();
       if (Tok.is(MMToken::Star)) 
-        ActiveModule->InferExportWildcard = true;
+        ActiveModule->InferExportWildcard = 1;
       else
         Diags.Report(Tok.getLocation(), 
                      diag::err_mmap_expected_export_wildcard);
       consumeToken();
       break;
 
     case MMToken::ExplicitKeyword:
     case MMToken::ModuleKeyword:
AttributeKind Attribute
           .Default(AT_unknown);
     switch (Attribute) {
     case AT_unknown:
       Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute)
         << Tok.getString();
       break;
 
     case AT_system:
-      Attrs.IsSystem = true;
+      Attrs.IsSystem = 1;
       break;
 
     case AT_extern_c:
-      Attrs.IsExternC = true;
+      Attrs.IsExternC = 1;
       break;
 
     case AT_exhaustive:
-      Attrs.IsExhaustive = true;
+      Attrs.IsExhaustive = 1;
       break;
     }
     consumeToken();
 
     // Consume the ']'.
     if (!Tok.is(MMToken::RSquare)) {
       Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare);
       Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match);

lib/Lex/PPMacroExpansion.cpp

   } else if (II == Ident__has_extension) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         return II && HasExtension(*this, II->getName());
       });
   } else if (II == Ident__has_builtin) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
-          return false;
+          return 0;
         else if (II->getBuiltinID() != 0)
-          return true;
+          return 1;
         else {
           const LangOptions &LangOpts = getLangOpts();
           return llvm::StringSwitch<bool>(II->getName())
                       .Case("__make_integer_seq", LangOpts.CPlusPlus)
                       .Default(false);
         }
       });
   } else if (II == Ident__is_identifier) {

       });
   } else if (II == Ident__has_cpp_attribute) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *ScopeII = nullptr;
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
-          return false;
+          return 0;
 
         // It is possible to receive a scope token.  Read the "::", if it is
         // available, and the subsequent identifier.
         LexUnexpandedToken(Tok);
         if (Tok.isNot(tok::coloncolon))
           HasLexedNextToken = true;
         else {
           ScopeII = II;

     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         std::string WarningName;
         SourceLocation StrStartLoc = Tok.getLocation();
 
         HasLexedNextToken = Tok.is(tok::string_literal);
         if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'",
                                     /*MacroExpansion=*/false))
-          return false;
+          return 0;
 
         // FIXME: Should we accept "-R..." flags here, or should that be
         // handled by a separate __has_remark?
         if (WarningName.size() < 3 || WarningName[0] != '-' ||
             WarningName[1] != 'W') {
           Diag(StrStartLoc, diag::warn_has_warning_invalid_option);
-          return false;
+          return 0;
         }
 
         // Finally, check if the warning flags maps to a diagnostic group.
         // We construct a SmallVector here to talk to getDiagnosticIDs().
         // Although we don't use the result, this isn't a hot path, and not
         // worth special casing.
         SmallVector<diag::kind, 10> Diags;
         return !getDiagnostics().getDiagnosticIDs()->

lib/Sema/DeclSpec.cpp

DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
   I.EndLoc                      = LocalRangeEnd;
   I.Fun.AttrList                = nullptr;
   I.Fun.hasPrototype            = hasProto;
   I.Fun.isVariadic              = EllipsisLoc.isValid();
   I.Fun.isAmbiguous             = isAmbiguous;
   I.Fun.LParenLoc               = LParenLoc.getRawEncoding();
   I.Fun.EllipsisLoc             = EllipsisLoc.getRawEncoding();
   I.Fun.RParenLoc               = RParenLoc.getRawEncoding();
-  I.Fun.DeleteParams            = false;
+  I.Fun.DeleteParams            = 0;
   I.Fun.TypeQuals               = TypeQuals;
   I.Fun.NumParams               = NumParams;
   I.Fun.Params                  = nullptr;
   I.Fun.RefQualifierIsLValueRef = RefQualifierIsLvalueRef;
   I.Fun.RefQualifierLoc         = RefQualifierLoc.getRawEncoding();
   I.Fun.ConstQualifierLoc       = ConstQualifierLoc.getRawEncoding();
   I.Fun.VolatileQualifierLoc    = VolatileQualifierLoc.getRawEncoding();
   I.Fun.RestrictQualifierLoc    = RestrictQualifierLoc.getRawEncoding();
DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto,
   if (NumParams) {
     // If the 'InlineParams' in Declarator is unused and big enough, put our
     // parameter list there (in an effort to avoid new/delete traffic).  If it
     // is already used (consider a function returning a function pointer) or too
     // small (function with too many parameters), go to the heap.
     if (!TheDeclarator.InlineParamsUsed &&
         NumParams <= llvm::array_lengthof(TheDeclarator.InlineParams)) {
       I.Fun.Params = TheDeclarator.InlineParams;
-      I.Fun.DeleteParams = false;
+      I.Fun.DeleteParams = 0;
       TheDeclarator.InlineParamsUsed = true;
     } else {
       I.Fun.Params = new DeclaratorChunk::ParamInfo[NumParams];
-      I.Fun.DeleteParams = true;
+      I.Fun.DeleteParams = 1;
     }
     memcpy(I.Fun.Params, Params, sizeof(Params[0]) * NumParams);
   }
 
   // Check what exception specification information we should actually store.
   switch (ESpecType) {
   default: break; // By default, save nothing.
   case EST_Dynamic:
if (TypeSpecType != TST_unspecified) {
     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
     DiagID = diag::err_invalid_decl_spec_combination;
     return true;
   }
   TypeSpecType = T;
   TypeRep = Rep;
   TSTLoc = TagKwLoc;
   TSTNameLoc = TagNameLoc;
-  TypeSpecOwned = false;
+  TypeSpecOwned = 0;
   return false;
 }
 
 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
                                const char *&PrevSpec,
                                unsigned &DiagID,
                                Expr *Rep,
                                const PrintingPolicy &Policy) {
   assert(isExprRep(T) && "T does not store an expr");
   assert(Rep && "no expression provided!");
   if (TypeSpecType != TST_unspecified) {
     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
     DiagID = diag::err_invalid_decl_spec_combination;
     return true;
   }
   TypeSpecType = T;
   ExprRep = Rep;
   TSTLoc = Loc;
   TSTNameLoc = Loc;
-  TypeSpecOwned = false;
+  TypeSpecOwned = 0;
   return false;
 }
 
 bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
                                const char *&PrevSpec,
                                unsigned &DiagID,
                                Decl *Rep, bool Owned,
                                const PrintingPolicy &Policy) {
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
   if (TypeSpecType != TST_unspecified) {
     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
     DiagID = diag::err_invalid_decl_spec_combination;
     return true;
   }
   TSTLoc = Loc;
   TSTNameLoc = Loc;
   if (TypeAltiVecVector && (T == TST_bool) && !TypeAltiVecBool) {
-    TypeAltiVecBool = true;
+    TypeAltiVecBool = 1;
     return false;
   }
   TypeSpecType = T;
-  TypeSpecOwned = false;
+  TypeSpecOwned = 0;
   return false;
 }
 
 bool DeclSpec::SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc,
                           const char *&PrevSpec, unsigned &DiagID,
                           const PrintingPolicy &Policy) {
   if (TypeSpecType != TST_unspecified) {
     PrevSpec = DeclSpec::getSpecifierName((TST) TypeSpecType, Policy);
bool DeclSpec::SetTypeAltiVecBool(bool isAltiVecBool, SourceLocation Loc,
   TypeAltiVecBool = isAltiVecBool;
   TSTLoc = Loc;
   TSTNameLoc = Loc;
   return false;
 }
 
 bool DeclSpec::SetTypeSpecError() {
   TypeSpecType = TST_error;
-  TypeSpecOwned = false;
+  TypeSpecOwned = 0;
   TSTLoc = SourceLocation();
   TSTNameLoc = SourceLocation();
   return false;
 }
 
 bool DeclSpec::SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec,
                            unsigned &DiagID, const LangOptions &Lang) {
   // Duplicates are permitted in C99 onwards, but are not permitted in C89 or
bool DeclSpec::setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
                                      unsigned &DiagID) {
   // 'inline inline' is ok.  However, since this is likely not what the user
   // intended, we will always warn, similar to duplicates of type qualifiers.
   if (FS_inline_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "inline";
     return true;
   }
-  FS_inline_specified = true;
+  FS_inline_specified = 1;
   FS_inlineLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
                                           unsigned &DiagID) {
   if (FS_forceinline_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "__forceinline";
     return true;
   }
-  FS_forceinline_specified = true;
+  FS_forceinline_specified = 1;
   FS_forceinlineLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecVirtual(SourceLocation Loc,
                                       const char *&PrevSpec,
                                       unsigned &DiagID) {
   // 'virtual virtual' is ok, but warn as this is likely not what the user
   // intended.
   if (FS_virtual_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "virtual";
     return true;
   }
-  FS_virtual_specified = true;
+  FS_virtual_specified = 1;
   FS_virtualLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
                                        const char *&PrevSpec,
                                        unsigned &DiagID) {
   // 'explicit explicit' is ok, but warn as this is likely not what the user
   // intended.
   if (FS_explicit_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "explicit";
     return true;
   }
-  FS_explicit_specified = true;
+  FS_explicit_specified = 1;
   FS_explicitLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
                                        const char *&PrevSpec,
                                        unsigned &DiagID) {
   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
   // intended.
   if (FS_noreturn_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "_Noreturn";
     return true;
   }
-  FS_noreturn_specified = true;
+  FS_noreturn_specified = 1;
   FS_noreturnLoc = Loc;
   return false;
 }
 
 bool DeclSpec::SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                              unsigned &DiagID) {
   if (Friend_specified) {
     PrevSpec = "friend";
     // Keep the later location, so that we can later diagnose ill-formed
     // declarations like 'friend class X friend;'. Per [class.friend]p3,
     // 'friend' must be the first token in a friend declaration that is
     // not a function declaration.
     FriendLoc = Loc;
     DiagID = diag::warn_duplicate_declspec;
     return true;
   }
 
-  Friend_specified = true;
+  Friend_specified = 1;
   FriendLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
                                     unsigned &DiagID) {
   if (isModulePrivateSpecified()) {
     PrevSpec = "__module_private__";
bool DeclSpec::SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
                                 unsigned &DiagID) {
   // 'constexpr constexpr' is ok, but warn as this is likely not what the user
   // intended.
   if (Constexpr_specified) {
     DiagID = diag::warn_duplicate_declspec;
     PrevSpec = "constexpr";
     return true;
   }
-  Constexpr_specified = true;
+  Constexpr_specified = 1;
   ConstexprLoc = Loc;
   return false;
 }
 
 bool DeclSpec::SetConceptSpec(SourceLocation Loc, const char *&PrevSpec,
                               unsigned &DiagID) {
   if (Concept_specified) {
     DiagID = diag::ext_duplicate_declspec;
     PrevSpec = "concept";
     return true;
   }
-  Concept_specified = true;
+  Concept_specified = 1;
   ConceptLoc = Loc;
   return false;
 }
 
 void DeclSpec::SaveWrittenBuiltinSpecs() {
   writtenBS.Sign = getTypeSpecSign();
   writtenBS.Width = getTypeSpecWidth();
   writtenBS.Type = getTypeSpecType();
for (unsigned I = 0; I != NumLocs; ++I) {
                                                            FirstLoc))
           FirstLoc = ExtraLocs[I];
         Hints[I] = FixItHint::CreateRemoval(ExtraLocs[I]);
       }
     }
     TypeSpecWidth = TSW_unspecified;
     TypeSpecComplex = TSC_unspecified;
     TypeSpecSign = TSS_unspecified;
-    TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = false;
+    TypeAltiVecVector = TypeAltiVecPixel = TypeAltiVecBool = 0;
     TypeQualifiers = 0;
     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
   }
 
   // Validate and finalize AltiVec vector declspec.
   if (TypeAltiVecVector) {
if (TypeAltiVecBool) {
           << getSpecifierName((TST)TypeSpecType, Policy);
     }
 
     if (TypeAltiVecPixel) {
       //TODO: perform validation
       TypeSpecType = TST_int;
       TypeSpecSign = TSS_unsigned;
       TypeSpecWidth = TSW_short;
-      TypeSpecOwned = false;
+      TypeSpecOwned = 0;
     }
   }
 
   // signed/unsigned are only valid with int/char/wchar_t.
   if (TypeSpecSign != TSS_unspecified) {
     if (TypeSpecType == TST_unspecified)
       TypeSpecType = TST_int; // unsigned -> unsigned int, signed -> signed int.
     else if (TypeSpecType != TST_int  && TypeSpecType != TST_int128 &&
void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
   case TSW_short:    // short int
   case TSW_longlong: // long long int
     if (TypeSpecType == TST_unspecified)
       TypeSpecType = TST_int; // short -> short int, long long -> long long int.
     else if (TypeSpecType != TST_int) {
       S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
         <<  getSpecifierName((TST)TypeSpecType, Policy);
       TypeSpecType = TST_int;
-      TypeSpecOwned = false;
+      TypeSpecOwned = 0;
     }
     break;
   case TSW_long:  // long double, long int
     if (TypeSpecType == TST_unspecified)
       TypeSpecType = TST_int;  // long -> long int.
     else if (TypeSpecType != TST_int && TypeSpecType != TST_double) {
       S.Diag(TSWLoc, diag::err_invalid_width_spec) << (int)TypeSpecWidth
         << getSpecifierName((TST)TypeSpecType, Policy);
       TypeSpecType = TST_int;
-      TypeSpecOwned = false;
+      TypeSpecOwned = 0;
     }
     break;
   }
 
   // TODO: if the implementation does not implement _Complex or _Imaginary,
   // disallow their use.  Need information about the backend.
   if (TypeSpecComplex != TSC_unspecified) {
     if (TypeSpecType == TST_unspecified) {
if (isVirtualSpecified()) {
       Keyword = "explicit";
       SCLoc = getExplicitSpecLoc();
     }
 
     FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
     S.Diag(SCLoc, diag::err_friend_decl_spec)
       << Keyword << Hint;
 
-    FS_virtual_specified = FS_explicit_specified = false;
+    FS_virtual_specified = FS_explicit_specified = 0;
     FS_virtualLoc = FS_explicitLoc = SourceLocation();
   }
 
   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
 
   // Okay, now we can infer the real type.
 
   // TODO: return "auto function" and other bad things based on the real type.

lib/Sema/Sema.cpp

for (TentativeDefinitionsType::iterator
     // return value is false.
     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
       continue;
 
     if (const IncompleteArrayType *ArrayT
         = Context.getAsIncompleteArrayType(VD->getType())) {
       // Set the length of the array to 1 (C99 6.9.2p5).
       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
-      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
+      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), 1);
       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
                                                 One, ArrayType::Normal, 0);
       VD->setType(T);
     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
                                    diag::err_tentative_def_incomplete_type))
       VD->setInvalidDecl();
 
     CheckCompleteVariableDeclaration(VD);

lib/Sema/SemaChecking.cpp

     const Expr *Ex = getDataArg(argIndex);
     const analyze_printf::ArgType &AT =
       (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
         ArgType(S.Context.IntTy) : ArgType::CPointerTy;
     if (AT.isValid() && !AT.matchesType(S.Context, Ex->getType()))
       EmitFormatDiagnostic(
         S.PDiag(diag::warn_format_conversion_argument_type_mismatch)
         << AT.getRepresentativeTypeName(S.Context) << Ex->getType()
-        << false << Ex->getSourceRange(),
+        << 0 << Ex->getSourceRange(),
         Ex->getLocStart(), /*IsStringLocation*/false,
         getSpecifierRange(startSpecifier, specifierLen));
 
     // Type check the second argument (char * for both %b and %D)
     Ex = getDataArg(argIndex + 1);
     const analyze_printf::ArgType &AT2 = ArgType::CStrTy;
     if (AT2.isValid() && !AT2.matchesType(S.Context, Ex->getType()))
       EmitFormatDiagnostic(
         S.PDiag(diag::warn_format_conversion_argument_type_mismatch)
         << AT2.getRepresentativeTypeName(S.Context) << Ex->getType()
-        << false << Ex->getSourceRange(),
+        << 0 << Ex->getSourceRange(),
         Ex->getLocStart(), /*IsStringLocation*/false,
         getSpecifierRange(startSpecifier, specifierLen));
 
      return true;
   }
 
   // Check for using an Objective-C specific conversion specifier
   // in a non-ObjC literal.

   if (success) {
     // Get the fix string from the fixed format specifier.
     SmallString<128> buf;
     llvm::raw_svector_ostream os(buf);
     fixedFS.toString(os);
 
     EmitFormatDiagnostic(
         S.PDiag(diag) << AT.getRepresentativeTypeName(S.Context)
-                      << Ex->getType() << false << Ex->getSourceRange(),
+                      << Ex->getType() << 0 << Ex->getSourceRange(),
         Ex->getLocStart(),
         /*IsStringLocation*/ false,
         getSpecifierRange(startSpecifier, specifierLen),
         FixItHint::CreateReplacement(
             getSpecifierRange(startSpecifier, specifierLen), os.str()));
   } else {
     EmitFormatDiagnostic(S.PDiag(diag)
                              << AT.getRepresentativeTypeName(S.Context)
-                             << Ex->getType() << false << Ex->getSourceRange(),
+                             << Ex->getType() << 0 << Ex->getSourceRange(),
                          Ex->getLocStart(),
                          /*IsStringLocation*/ false,
                          getSpecifierRange(startSpecifier, specifierLen));
   }
 
   return true;
 }
 

lib/Sema/SemaCodeComplete.cpp

 
   llvm_unreachable("Invalid ParserCompletionContext!");
 }
 
 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
                                                   const Preprocessor &PP) {
   PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
   Policy.AnonymousTagLocations = false;
-  Policy.SuppressStrongLifetime = true;
+  Policy.SuppressStrongLifetime = 1;
   Policy.SuppressUnwrittenScope = true;
   return Policy;
 }
 
 /// \brief Retrieve a printing policy suitable for code completion.
 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
   return getCompletionPrintingPolicy(S.Context, S.PP);
 }

lib/Sema/SemaDecl.cpp

 
     // Special cases for arrays:
     //   - if it's const, use __unsafe_unretained
     //   - otherwise, it's an error
     if (T->isArrayType()) {
       if (!T.isConstQualified()) {
         DelayedDiagnostics.add(
             sema::DelayedDiagnostic::makeForbiddenType(
-            NameLoc, diag::err_arc_array_param_no_ownership, T, false));
+            NameLoc, diag::err_arc_array_param_no_ownership, T, 0));
       }
       lifetime = Qualifiers::OCL_ExplicitNone;
     } else {
       lifetime = T->getObjCARCImplicitLifetime();
     }
     T = Context.getLifetimeQualifiedType(T, lifetime);
   }
 

lib/Sema/SemaDeclAttr.cpp

   if (NumParams == 2 &&
       (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
        S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
     S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
            diag::err_anyx86_interrupt_attribute)
         << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
                 ? 0
                 : 1)
-        << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
+        << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/0);
     return;
   }
   D->addAttr(::new (S.Context) AnyX86InterruptAttr(
       Attr.getLoc(), S.Context, Attr.getAttributeSpellingListIndex()));
   D->addAttr(UsedAttr::CreateImplicit(S.Context));
 }
 
 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {

lib/Sema/SemaDeclCXX.cpp

                llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
                CTK_ErrorRecovery, ClassDecl))) {
         if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
           // We have found a non-static data member with a similar
           // name to what was typed; complain and initialize that
           // member.
           diagnoseTypo(Corr,
                        PDiag(diag::err_mem_init_not_member_or_class_suggest)
-                         << MemberOrBase << true);
+                         << MemberOrBase << 1);
           return BuildMemberInitializer(Member, Init, IdLoc);
         } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
           const CXXBaseSpecifier *DirectBaseSpec;
           const CXXBaseSpecifier *VirtualBaseSpec;
           if (FindBaseInitializer(*this, ClassDecl, 
                                   Context.getTypeDeclType(Type),
                                   DirectBaseSpec, VirtualBaseSpec)) {
             // We have found a direct or virtual base class with a
             // similar name to what was typed; complain and initialize
             // that base class.
             diagnoseTypo(Corr,
                          PDiag(diag::err_mem_init_not_member_or_class_suggest)
-                           << MemberOrBase << false,
+                           << MemberOrBase << 0,
                          PDiag() /*Suppress note, we provide our own.*/);
 
             const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
                                                               : VirtualBaseSpec;
             Diag(BaseSpec->getLocStart(),
                  diag::note_base_class_specified_here)
               << BaseSpec->getType()
               << BaseSpec->getSourceRange();

lib/Sema/SemaDeclObjC.cpp

         ++numTypeDeclsResolved;
         continue;
       }
 
       // Did we find an Objective-C class?
       if (auto objcClass = corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
         diagnoseTypo(corrected,
                      PDiag(diag::err_unknown_type_or_class_name_suggest)
-                       << identifiers[i] << true);
+                       << identifiers[i] << 1);
         lookupKind = LookupOrdinaryName;
         typeDecls[i] = objcClass;
         ++numTypeDeclsResolved;
         continue;
       }
     }
 
     // We couldn't find anything.

lib/Sema/SemaOpenMP.cpp

   if (E == nullptr)
     return ExprError();
   auto &C = SemaRef.Context;
   QualType OldType = E->getType();
   unsigned HasBits = C.getTypeSize(OldType);
   if (HasBits >= Bits)
     return ExprResult(E);
   // OK to convert to signed, because new type has more bits than old.
-  QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
+  QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ 1);
   return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
                                            true);
 }
 
 /// \brief Check if the given expression \a E is a constant integer that fits
 /// into \a Bits bits.
 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
   if (E == nullptr)

     VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
     UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
     SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
                                  /*DirectInit*/ false,
                                  /*TypeMayContainAuto*/ false);
 
     // A 32-bit variable-flag where runtime returns 1 for the last iteration.
     // This will be used to implement clause 'lastprivate'.
-    QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
+    QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, 1);
     VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
     IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
     SemaRef.AddInitializerToDecl(
         ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
         /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
 
     // Stride variable returned by runtime (we initialize it to 1 by default).
     VarDecl *STDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.stride");

                     : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get();
     Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS);
     Init = SemaRef.ActOnFinishFullExpr(Init.get());
   }
 
   // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops.
   SourceLocation CondLoc;
   ExprResult Cond =
       (isOpenMPWorksharingDirective(DKind) ||
        isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind))
           ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get())
           : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(),
                                NumIterations.get());
 
   // Loop increment (IV = IV + 1)
   SourceLocation IncLoc;
   ExprResult Inc =

lib/Sema/SemaOverload.cpp

 }
 
 /// StandardConversionSequence - Set the standard conversion
 /// sequence to the identity conversion.
 void StandardConversionSequence::setAsIdentityConversion() {
   First = ICK_Identity;
   Second = ICK_Identity;
   Third = ICK_Identity;
-  DeprecatedStringLiteralToCharPtr = false;
-  QualificationIncludesObjCLifetime = false;
-  ReferenceBinding = false;
-  DirectBinding = false;
-  IsLvalueReference = true;
-  BindsToFunctionLvalue = false;
-  BindsToRvalue = false;
-  BindsImplicitObjectArgumentWithoutRefQualifier = false;
-  ObjCLifetimeConversionBinding = false;
+  DeprecatedStringLiteralToCharPtr = 0;
+  QualificationIncludesObjCLifetime = 0;
+  ReferenceBinding = 0;
+  DirectBinding = 0;
+  IsLvalueReference = 1;
+  BindsToFunctionLvalue = 0;
+  BindsToRvalue = 0;
+  BindsImplicitObjectArgumentWithoutRefQualifier = 0;
+  ObjCLifetimeConversionBinding = 0;
   CopyConstructor = nullptr;
 }
 
 /// getRank - Retrieve the rank of this standard conversion sequence
 /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
 /// implicit conversions.
 ImplicitConversionRank StandardConversionSequence::getRank() const {
   ImplicitConversionRank Rank = ICR_Exact_Match;

 /// \brief Convert from Sema's representation of template deduction information
 /// to the form used in overload-candidate information.
 DeductionFailureInfo
 clang::MakeDeductionFailureInfo(ASTContext &Context,
                                 Sema::TemplateDeductionResult TDK,
                                 TemplateDeductionInfo &Info) {
   DeductionFailureInfo Result;
   Result.Result = static_cast<unsigned>(TDK);
-  Result.HasDiagnostic = false;
+  Result.HasDiagnostic = 0;
   switch (TDK) {
   case Sema::TDK_Success:
   case Sema::TDK_Invalid:
   case Sema::TDK_InstantiationDepth:
   case Sema::TDK_TooManyArguments:
   case Sema::TDK_TooFewArguments:
   case Sema::TDK_MiscellaneousDeductionFailure:
     Result.Data = nullptr;

   }
 
   case Sema::TDK_SubstitutionFailure:
     Result.Data = Info.take();
     if (Info.hasSFINAEDiagnostic()) {
       PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
           SourceLocation(), PartialDiagnostic::NullDiagnostic());
       Info.takeSFINAEDiagnostic(*Diag);
-      Result.HasDiagnostic = true;
+      Result.HasDiagnostic = 1;
     }
     break;
 
   case Sema::TDK_FailedOverloadResolution:
     Result.Data = Info.Expression;
     break;
   }
 

     Data = nullptr;
     break;
 
   case Sema::TDK_SubstitutionFailure:
     // FIXME: Destroy the template argument list?
     Data = nullptr;
     if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
       Diag->~PartialDiagnosticAt();
-      HasDiagnostic = false;
+      HasDiagnostic = 0;
     }
     break;
 
   // Unhandled
   case Sema::TDK_MiscellaneousDeductionFailure:
     break;
   }
 }

                                  bool InOverloadResolution,
                                  StandardConversionSequence &SCS,
                                  bool CStyle,
                                  bool AllowObjCWritebackConversion) {
   QualType FromType = From->getType();
 
   // Standard conversions (C++ [conv])
   SCS.setAsIdentityConversion();
-  SCS.IncompatibleObjC = false;
+  SCS.IncompatibleObjC = 0;
   SCS.setFromType(FromType);
   SCS.CopyConstructor = nullptr;
 
   // There are no standard conversions for class types in C++, so
   // abort early. When overloading in C, however, we do permit them.
   if (S.getLangOpts().CPlusPlus &&
       (FromType->isRecordType() || ToType->isRecordType()))
     return false;

 
     // An lvalue or rvalue of type "array of N T" or "array of unknown
     // bound of T" can be converted to an rvalue of type "pointer to
     // T" (C++ 4.2p1).
     FromType = S.Context.getArrayDecayedType(FromType);
 
     if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
       // This conversion is deprecated in C++03 (D.4)
-      SCS.DeprecatedStringLiteralToCharPtr = true;
+      SCS.DeprecatedStringLiteralToCharPtr = 1;
 
       // For the purpose of ranking in overload resolution
       // (13.3.3.1.1), this conversion is considered an
       // array-to-pointer conversion followed by a qualification
       // conversion (4.4). (C++ 4.2p2)
       SCS.Second = ICK_Identity;
       SCS.Third = ICK_Qualification;
-      SCS.QualificationIncludesObjCLifetime = false;
+      SCS.QualificationIncludesObjCLifetime = 0;
       SCS.setAllToTypes(FromType);
       return true;
     }
   } else if (FromType->isFunctionType() && argIsLValue) {
     // Function-to-pointer conversion (C++ 4.3).
     SCS.First = ICK_Function_To_Pointer;
 
     if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))

       ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
                          : ObjCConversion? ICK_Compatible_Conversion
                          : ICK_Identity;
       ICS.Standard.Third = ICK_Identity;
       ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
       ICS.Standard.setToType(0, T2);
       ICS.Standard.setToType(1, T1);
       ICS.Standard.setToType(2, T1);
-      ICS.Standard.ReferenceBinding = true;
-      ICS.Standard.DirectBinding = true;
+      ICS.Standard.ReferenceBinding = 1;
+      ICS.Standard.DirectBinding = 1;
       ICS.Standard.IsLvalueReference = !isRValRef;
       ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
-      ICS.Standard.BindsToRvalue = false;
-      ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+      ICS.Standard.BindsToRvalue = 0;
+      ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = 0;
       ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
       ICS.Standard.CopyConstructor = nullptr;
-      ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
+      ICS.Standard.DeprecatedStringLiteralToCharPtr = 0;
 
       // Nothing more to do: the inaccessibility/ambiguity check for
       // derived-to-base conversions is suppressed when we're
       // computing the implicit conversion sequence (C++
       // [over.best.ics]p2).
       return ICS;
     }
 

     ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base
                       : ObjCConversion? ICK_Compatible_Conversion
                       : ICK_Identity;
     ICS.Standard.Third = ICK_Identity;
     ICS.Standard.FromTypePtr = T2.getAsOpaquePtr();
     ICS.Standard.setToType(0, T2);
     ICS.Standard.setToType(1, T1);
     ICS.Standard.setToType(2, T1);
-    ICS.Standard.ReferenceBinding = true;
+    ICS.Standard.ReferenceBinding = 1;
     // In C++0x, this is always a direct binding. In C++98/03, it's a direct
     // binding unless we're binding to a class prvalue.
     // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
     // allow the use of rvalue references in C++98/03 for the benefit of
     // standard library implementors; therefore, we need the xvalue check here.
     ICS.Standard.DirectBinding =
       S.getLangOpts().CPlusPlus11 ||
       !(InitCategory.isPRValue() || T2->isRecordType());
     ICS.Standard.IsLvalueReference = !isRValRef;
     ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
     ICS.Standard.BindsToRvalue = InitCategory.isRValue();
-    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = 0;
     ICS.Standard.ObjCLifetimeConversionBinding = ObjCLifetimeConversion;
     ICS.Standard.CopyConstructor = nullptr;
-    ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
+    ICS.Standard.DeprecatedStringLiteralToCharPtr = 0;
     return ICS;
   }
 
   //            -- has a class type (i.e., T2 is a class type), where T1 is not
   //               reference-related to T2, and can be implicitly converted to
   //               an xvalue, class prvalue, or function lvalue of type
   //               "cv3 T3", where "cv1 T1" is reference-compatible with
   //               "cv3 T3",

                               /*AllowExplicit=*/false,
                               /*InOverloadResolution=*/false,
                               /*CStyle=*/false,
                               /*AllowObjCWritebackConversion=*/false,
                               /*AllowObjCConversionOnExplicit=*/false);
 
   // Of course, that's still a reference binding.
   if (ICS.isStandard()) {
-    ICS.Standard.ReferenceBinding = true;
+    ICS.Standard.ReferenceBinding = 1;
     ICS.Standard.IsLvalueReference = !isRValRef;
-    ICS.Standard.BindsToFunctionLvalue = false;
-    ICS.Standard.BindsToRvalue = true;
-    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
-    ICS.Standard.ObjCLifetimeConversionBinding = false;
+    ICS.Standard.BindsToFunctionLvalue = 0;
+    ICS.Standard.BindsToRvalue = 1;
+    ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = 0;
+    ICS.Standard.ObjCLifetimeConversionBinding = 0;
   } else if (ICS.isUserDefined()) {
     const ReferenceType *LValRefType =
         ICS.UserDefined.ConversionFunction->getReturnType()
             ->getAs<LValueReferenceType>();
 
     // C++ [over.ics.ref]p3:
     //   Except for an implicit object parameter, for which see 13.3.1, a
     //   standard conversion sequence cannot be formed if it requires [...]
     //   binding an rvalue reference to an lvalue other than a function
     //   lvalue.
     // Note that the function case is not possible here.
     if (DeclType->isRValueReferenceType() && LValRefType) {
       // FIXME: This is the wrong BadConversionSequence. The problem is binding
       // an rvalue reference to a (non-function) lvalue, not binding an lvalue
       // reference to an rvalue!
       ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
       return ICS;
     }
 
     ICS.UserDefined.Before.setAsIdentityConversion();
-    ICS.UserDefined.After.ReferenceBinding = true;
+    ICS.UserDefined.After.ReferenceBinding = 1;
     ICS.UserDefined.After.IsLvalueReference = !isRValRef;
-    ICS.UserDefined.After.BindsToFunctionLvalue = false;
+    ICS.UserDefined.After.BindsToFunctionLvalue = 0;
     ICS.UserDefined.After.BindsToRvalue = !LValRefType;
-    ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
-    ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
+    ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = 0;
+    ICS.UserDefined.After.ObjCLifetimeConversionBinding = 0;
   }
 
   return ICS;
 }
 
 static ImplicitConversionSequence
 TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
                       bool SuppressUserConversions,

     assert(!Result.isEllipsis() &&
            "Sub-initialization cannot result in ellipsis conversion.");
 
     // Can we even bind to a temporary?
     if (ToType->isRValueReferenceType() ||
         (T1.isConstQualified() && !T1.isVolatileQualified())) {
       StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
                                             Result.UserDefined.After;
-      SCS.ReferenceBinding = true;
+      SCS.ReferenceBinding = 1;
       SCS.IsLvalueReference = ToType->isLValueReferenceType();
-      SCS.BindsToRvalue = true;
-      SCS.BindsToFunctionLvalue = false;
-      SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
-      SCS.ObjCLifetimeConversionBinding = false;
+      SCS.BindsToRvalue = 1;
+      SCS.BindsToFunctionLvalue = 0;
+      SCS.BindsImplicitObjectArgumentWithoutRefQualifier = 0;
+      SCS.ObjCLifetimeConversionBinding = 0;
     } else
       Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
                     From, ToType);
     return Result;
   }
 
   // C++14 [over.ics.list]p7:
   // C++11 [over.ics.list]p6:

   }
 
   // Success. Mark this as a reference binding.
   ICS.setStandard();
   ICS.Standard.setAsIdentityConversion();
   ICS.Standard.Second = SecondKind;
   ICS.Standard.setFromType(FromType);
   ICS.Standard.setAllToTypes(ImplicitParamType);
-  ICS.Standard.ReferenceBinding = true;
-  ICS.Standard.DirectBinding = true;
+  ICS.Standard.ReferenceBinding = 1;
+  ICS.Standard.DirectBinding = 1;
   ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
-  ICS.Standard.BindsToFunctionLvalue = false;
+  ICS.Standard.BindsToFunctionLvalue = 0;
   ICS.Standard.BindsToRvalue = FromClassification.isRValue();
   ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
     = (Method->getRefQualifier() == RQ_None);
   return ICS;
 }
 
 /// PerformObjectArgumentInitialization - Perform initialization of
 /// the implicit object parameter for the given Method with the given

lib/Sema/SemaStmt.cpp

 class CatchHandlerType {
   QualType QT;
   unsigned IsPointer : 1;
 
   // This is a special constructor to be used only with DenseMapInfo's
   // getEmptyKey() and getTombstoneKey() functions.
   friend struct llvm::DenseMapInfo<CatchHandlerType>;
   enum Unique { ForDenseMap };
-  CatchHandlerType(QualType QT, Unique) : QT(QT), IsPointer(false) {}
+  CatchHandlerType(QualType QT, Unique) : QT(QT), IsPointer(0) {}
 
 public:
   /// Used when creating a CatchHandlerType from a handler type; will determine
   /// whether the type is a pointer or reference and will strip off the top
   /// level pointer and cv-qualifiers.
-  CatchHandlerType(QualType Q) : QT(Q), IsPointer(false) {
+  CatchHandlerType(QualType Q) : QT(Q), IsPointer(0) {
     if (QT->isPointerType())
-      IsPointer = true;
+      IsPointer = 1;
 
     if (IsPointer || QT->isReferenceType())
       QT = QT->getPointeeType();
     QT = QT.getUnqualifiedType();
   }
 
   /// Used when creating a CatchHandlerType from a base class type; pretends the
   /// type passed in had the pointer qualifier, does not need to get an

lib/Sema/SemaType.cpp

 static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
                                           QualType declSpecType) {
   Declarator &declarator = state.getDeclarator();
 
   // First, check whether the declarator would produce a function,
   // i.e. whether the innermost semantic chunk is a function.
   if (declarator.isFunctionDeclarator()) {
     // If so, make that declarator a prototyped declarator.
-    declarator.getFunctionTypeInfo().hasPrototype = true;
+    declarator.getFunctionTypeInfo().hasPrototype = 1;
     return;
   }
 
   // If there are any type objects, the type as written won't name a
   // function, regardless of the decl spec type.  This is because a
   // block signature declarator is always an abstract-declarator, and
   // abstract-declarators can't just be parentheses chunks.  Therefore
   // we need to build a function chunk unless there are no type

lib/Serialization/ASTReader.cpp

     // going to use this information to rebuild the module, so it doesn't make
     // a lot of difference.
     Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
     ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
     HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
   }
 
   // This HeaderFileInfo was externally loaded.
-  HFI.External = true;
-  HFI.IsValid = true;
+  HFI.External = 1;
+  HFI.IsValid = 1;
   return HFI;
 }
 
 void ASTReader::addPendingMacro(IdentifierInfo *II,
                                 ModuleFile *M,
                                 uint64_t MacroDirectivesOffset) {
   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));

       List->setMethod(Method);
   }
 }
 
 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
   assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
   for (Decl *D : Names) {
     bool wasHidden = D->Hidden;
-    D->Hidden = false;
+    D->Hidden = 0;
 
     if (wasHidden && SemaObj) {
       if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
         moveMethodToBackOfGlobalList(*SemaObj, Method);
       }
     }
   }
 }

             return Failure;
           }
         }
 
         CurrentModule->setASTFile(F.File);
       }
 
       CurrentModule->Signature = F.Signature;
-      CurrentModule->IsFromModuleFile = true;
+      CurrentModule->IsFromModuleFile = 1;
       CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
       CurrentModule->IsExternC = IsExternC;
       CurrentModule->InferSubmodules = InferSubmodules;
       CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
       CurrentModule->InferExportWildcard = InferExportWildcard;
       CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
       if (DeserializationListener)
         DeserializationListener->ModuleRead(GlobalID, CurrentModule);

         
     case SUBMODULE_IMPORTS: {
       for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
         UnresolvedModuleRef Unresolved;
         Unresolved.File = &F;
         Unresolved.Mod = CurrentModule;
         Unresolved.ID = Record[Idx];
         Unresolved.Kind = UnresolvedModuleRef::Import;
-        Unresolved.IsWildcard = false;
+        Unresolved.IsWildcard = 0;
         UnresolvedModuleRefs.push_back(Unresolved);
       }
       break;
     }
 
     case SUBMODULE_EXPORTS: {
       for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
         UnresolvedModuleRef Unresolved;

       break;
 
     case SUBMODULE_CONFLICT: {
       UnresolvedModuleRef Unresolved;
       Unresolved.File = &F;
       Unresolved.Mod = CurrentModule;
       Unresolved.ID = Record[0];
       Unresolved.Kind = UnresolvedModuleRef::Conflict;
-      Unresolved.IsWildcard = false;
+      Unresolved.IsWildcard = 0;
       Unresolved.String = Blob;
       UnresolvedModuleRefs.push_back(Unresolved);
       break;
     }
     }
   }
 }
 

       Error("incorrect encoding of typeof(type) in AST file");
       return QualType();
     }
     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
     return Context.getTypeOfType(UnderlyingType);
   }
 
   case TYPE_DECLTYPE: {
     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
     return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
   }
 
   case TYPE_UNARY_TRANSFORM: {
     QualType BaseType = readType(*Loc.F, Record, Idx);
     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
     UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
     return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
   }
 
   case TYPE_AUTO: {
     QualType Deduced = readType(*Loc.F, Record, Idx);
     AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
-    bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
+    bool IsDependent = Deduced.isNull() ? Record[Idx++] : 0;
     return Context.getAutoType(Deduced, Keyword, IsDependent);
   }
 
   case TYPE_RECORD: {
     if (Record.size() != 2) {
       Error("incorrect encoding of record type");
       return QualType();
     }

lib/Serialization/ASTReaderDecl.cpp

public:
 
     /// We've merged the definition \p MergedDef into the existing definition
     /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
     /// visible.
     void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef) {
       if (Def->isHidden()) {
         // If MergedDef is visible or becomes visible, make the definition visible.
         if (!MergedDef->isHidden())
-          Def->Hidden = false;
+          Def->Hidden = 0;
         else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
           Reader.getContext().mergeDefinitionIntoModule(
               Def, MergedDef->getImportedOwningModule(),
               /*NotifyListeners*/ false);
           Reader.PendingMergedDefinitionsToDeduplicate.insert(Def);
         } else {
           auto SubmoduleID = MergedDef->getOwningModuleID();
           assert(SubmoduleID && "hidden definition in no module");
if (Record[Idx++]) { // hasAttrs
     // internally which is unsafe during derialization.
     D->setAttrsImpl(Attrs, Reader.getContext());
   }
   D->setImplicit(Record[Idx++]);
   D->Used = Record[Idx++];
   D->setReferenced(Record[Idx++]);
   D->setTopLevelDeclInObjCContainer(Record[Idx++]);
   D->setAccess((AccessSpecifier)Record[Idx++]);
-  D->FromASTFile = true;
+  D->FromASTFile = 1;
   D->setModulePrivate(Record[Idx++]);
   D->Hidden = D->isModulePrivate();
 
   // Determine whether this declaration is part of a (sub)module. If so, it
   // may not yet be visible.
   if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
     // Store the owning submodule ID in the declaration.
     D->setOwningModuleID(SubmoduleID);
 
     if (D->Hidden) {
       // Module-private declarations are never visible, so there is no work to do.
     } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
       // If local visibility is being tracked, this declaration will become
       // hidden and visible as the owning module does. Inform Sema that this
       // declaration might not be visible.
-      D->Hidden = true;
+      D->Hidden = 1;
     } else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
       if (Owner->NameVisibility != Module::AllVisible) {
         // The owning module is not visible. Mark this declaration as hidden.
-        D->Hidden = true;
+        D->Hidden = 1;
         
         // Note that this declaration was hidden because its owning module is 
         // not yet visible.
         Reader.HiddenNamesMap[Owner].push_back(D);
       }
     }
   }
 }
if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
     DetectedOdrViolation = true;
   // FIXME: Issue a diagnostic if the base classes don't match when we come
   // to lazily load them.
 
   // FIXME: Issue a diagnostic if the list of conversion functions doesn't
   // match when we come to lazily load them.
   if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
     DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
-    DD.ComputedVisibleConversions = true;
+    DD.ComputedVisibleConversions = 1;
   }
 
   // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
   // lazily load it.
 
   if (DD.IsLambda) {
     // FIXME: ODR-checking for merging lambdas (this happens, for instance,
     // when they occur within the body of a function template specialization).
if (PrevFD->IsInline != FD->IsInline) {
     // module A:
     //   template<typename T> struct X { void f(); };
     //   template<typename T> inline void X<T>::f() {}
     //
     // module B instantiates the declaration of X<int>::f
     // module C instantiates the definition of X<int>::f
     //
     // If module B and C are merged, we do not have a violation of this rule.
-    FD->IsInline = true;
+    FD->IsInline = 1;
   }
 
   // If we need to propagate an exception specification along the redecl
   // chain, make a note of that so that we can do so later.
   auto *FPT = FD->getType()->getAs<FunctionProtoType>();
   auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
   if (FPT && PrevFPT) {
     bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());
#include "clang/AST/DeclNodes.inc"
   //        that makes it visible has been imported.
   D->IdentifierNamespace |=
       Previous->IdentifierNamespace &
       (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
 
   // If the previous declaration is marked as used, then this declaration should
   // be too.
   if (Previous->Used)
-    D->Used = true;
+    D->Used = 1;
 
   // If the declaration declares a template, it may inherit default arguments
   // from the previous declaration.
   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
     inheritDefaultTemplateArguments(Reader.getContext(),
                                     cast<TemplateDecl>(Previous), TD);
 }
 
case UPD_CXX_DEDUCED_RETURN_TYPE: {
       break;
     }
 
     case UPD_DECL_MARKED_USED: {
       // FIXME: This doesn't send the right notifications if there are
       // ASTMutationListeners other than an ASTWriter.
 
       // Maintain AST consistency: any later redeclarations are used too.
-      forAllLaterRedecls(D, [](Decl *D) { D->Used = true; });
+      forAllLaterRedecls(D, [](Decl *D) { D->Used = 1; });
       break;
     }
 
     case UPD_MANGLING_NUMBER:
       Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
       break;
 
     case UPD_STATIC_LOCAL_NUMBER:
case UPD_DECL_EXPORTED: {
         Reader.PendingMergedDefinitionsToDeduplicate.insert(
             cast<NamedDecl>(Exported));
       } else if (Owner && Owner->NameVisibility != Module::AllVisible) {
         // If Owner is made visible at some later point, make this declaration
         // visible too.
         Reader.HiddenNamesMap[Owner].push_back(Exported);
       } else {
         // The declaration is now visible.
-        Exported->Hidden = false;
+        Exported->Hidden = 0;
       }
       break;
     }
 
     case UPD_ADDED_ATTR_TO_RECORD:
       AttrVec Attrs;
       Reader.ReadAttributes(F, Attrs, Record, Idx);
       assert(Attrs.size() == 1);
       D->addAttr(Attrs[0]);
       break;
     }
   }
 }

lib/Serialization/ASTWriter.cpp

           Record.push_back(Spec->getTemplateSpecializationKind());
           Record.AddSourceLocation(Spec->getPointOfInstantiation());
 
           // The instantiation might have been resolved to a partial
           // specialization. If so, record which one.
           auto From = Spec->getInstantiatedFrom();
           if (auto PartialSpec =
                 From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) {
-            Record.push_back(true);
+            Record.push_back(1);
             Record.AddDeclRef(PartialSpec);
             Record.AddTemplateArgumentList(
                 &Spec->getTemplateInstantiationArgs());
           } else {
-            Record.push_back(false);
+            Record.push_back(0);
           }
         }
         Record.push_back(RD->getTagKind());
         Record.AddSourceLocation(RD->getLocation());
         Record.AddSourceLocation(RD->getLocStart());
         Record.AddSourceLocation(RD->getRBraceLoc());
 
         // Instantiation may change attributes; write them all out afresh.

lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 class CFGDumper : public Checker<check::ASTCodeBody> {
 public:
   void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
                         BugReporter &BR) const {
     PrintingPolicy Policy(mgr.getLangOpts());
-    Policy.TerseOutput = true;
-    Policy.PolishForDeclaration = true;
+    Policy.TerseOutput = 1;
+    Policy.PolishForDeclaration = 1;
     D->print(llvm::errs(), Policy);
 
     if (CFG *cfg = mgr.getCFG(D)) {
       cfg->dump(mgr.getLangOpts(),
                 llvm::sys::Process::StandardErrHasColors());
     }
   }
 };

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

void ModelInjector::onBodySynthesis(const NamedDecl *D) {
 
   IntrusiveRefCntPtr<CompilerInvocation> Invocation(
       new CompilerInvocation(CI.getInvocation()));
 
   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
   InputKind IK = IK_CXX; // FIXME
   FrontendOpts.Inputs.clear();
   FrontendOpts.Inputs.emplace_back(fileName, IK);
-  FrontendOpts.DisableFree = true;
+  FrontendOpts.DisableFree = 1;
 
   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
 
   // Modules are parsed by a separate CompilerInstance, so this code mimics that
   // behavior for models
   CompilerInstance Instance(CI.getPCHContainerOperations());
   Instance.setInvocation(&*Invocation);
   Instance.createDiagnostics(

lib/Tooling/Core/QualTypeNames.cpp

QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
   return QT;
 }
 
 std::string getFullyQualifiedName(QualType QT,
                                   const ASTContext &Ctx) {
   PrintingPolicy Policy(Ctx.getPrintingPolicy());
   Policy.SuppressScope = false;
   Policy.AnonymousTagLocations = false;
-  Policy.PolishForDeclaration = true;
+  Policy.PolishForDeclaration = 1;
   Policy.SuppressUnwrittenScope = true;
   QualType FQQT = getFullyQualifiedType(QT, Ctx);
   return FQQT.getAsString(Policy);
 }
 
 }  // end namespace TypeName
 }  // end namespace clang

lib/Tooling/Tooling.cpp

 clang::CompilerInvocation *newInvocation(
     clang::DiagnosticsEngine *Diagnostics,
     const llvm::opt::ArgStringList &CC1Args) {
   assert(!CC1Args.empty() && "Must at least contain the program name!");
   clang::CompilerInvocation *Invocation = new clang::CompilerInvocation;
   clang::CompilerInvocation::CreateFromArgs(
       *Invocation, CC1Args.data() + 1, CC1Args.data() + CC1Args.size(),
       *Diagnostics);
-  Invocation->getFrontendOpts().DisableFree = false;
-  Invocation->getCodeGenOpts().DisableFree = false;
+  Invocation->getFrontendOpts().DisableFree = 0;
+  Invocation->getCodeGenOpts().DisableFree = 0;
   Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
   return Invocation;
 }
 
 bool runToolOnCode(clang::FrontendAction *ToolAction, const Twine &Code,
                    const Twine &FileName,
                    std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
   return runToolOnCodeWithArgs(ToolAction, Code, std::vector<std::string>(),

tools/libclang/CIndex.cpp

     return ME.getName();
   }
   return nullptr;
 }
 
 unsigned clang_Cursor_isMacroFunctionLike(CXCursor C) {
   const IdentifierInfo *II = getMacroIdentifier(C);
   if (!II) {
-    return false;
+    return 0;
   }
   ASTUnit *ASTU = getCursorASTUnit(C);
   Preprocessor &PP = ASTU->getPreprocessor();
   if (const MacroInfo *MI = PP.getMacroInfo(II))
     return MI->isFunctionLike();
-  return false;
+  return 0;
 }
 
 unsigned clang_Cursor_isMacroBuiltin(CXCursor C) {
   const IdentifierInfo *II = getMacroIdentifier(C);
   if (!II) {
-    return false;
+    return 0;
   }
   ASTUnit *ASTU = getCursorASTUnit(C);
   Preprocessor &PP = ASTU->getPreprocessor();
   if (const MacroInfo *MI = PP.getMacroInfo(II))
     return MI->isBuiltinMacro();
-  return false;
+  return 0;
 }
 
 unsigned clang_Cursor_isFunctionInlined(CXCursor C) {
   const Decl *D = getCursorDecl(C);
   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
   if (!FD) {
-    return false;
+    return 0;
   }
   return FD->isInlined();
 }
 
 static StringLiteral* getCFSTR_value(CallExpr *callExpr) {
   if (callExpr->getNumArgs() != 1) {
     return nullptr;
   }

   outID->data[0] = ID.getDevice();
   outID->data[1] = ID.getFile();
   outID->data[2] = FEnt->getModificationTime();
   return 0;
 }
 
 int clang_File_isEqual(CXFile file1, CXFile file2) {
   if (file1 == file2)
-    return true;
+    return 1;
 
   if (!file1 || !file2)
-    return false;
+    return 0;
 
   FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
   FileEntry *FEnt2 = static_cast<FileEntry *>(file2);
   return FEnt1->getUniqueID() == FEnt2->getUniqueID();
 }
 
 } // end: extern "C"
 

 }
   
 unsigned clang_isUnexposed(enum CXCursorKind K) {
   switch (K) {
     case CXCursor_UnexposedDecl:
     case CXCursor_UnexposedExpr:
     case CXCursor_UnexposedStmt:
     case CXCursor_UnexposedAttr:
-      return true;
+      return 1;
     default:
-      return false;
+      return 0;
   }
 }
 
 CXCursorKind clang_getCursorKind(CXCursor C) {
   return C.kind;
 }
 
 CXSourceLocation clang_getCursorLocation(CXCursor C) {

tools/libclang/CXComment.cpp

if (!C || ChildIdx >= C->child_count())
     return createCXComment(nullptr, nullptr);
 
   return createCXComment(*(C->child_begin() + ChildIdx), CXC.TranslationUnit);
 }
 
 unsigned clang_Comment_isWhitespace(CXComment CXC) {
   const Comment *C = getASTNode(CXC);
   if (!C)
-    return false;
+    return 0;
 
   if (const TextComment *TC = dyn_cast<TextComment>(C))
     return TC->isWhitespace();
 
   if (const ParagraphComment *PC = dyn_cast<ParagraphComment>(C))
     return PC->isWhitespace();
 
-  return false;
+  return 0;
 }
 
 unsigned clang_InlineContentComment_hasTrailingNewline(CXComment CXC) {
   const InlineContentComment *ICC = getASTNodeAs<InlineContentComment>(CXC);
   if (!ICC)
-    return false;
+    return 0;
 
   return ICC->hasTrailingNewline();
 }
 
 CXString clang_TextComment_getText(CXComment CXC) {
   const TextComment *TC = getASTNodeAs<TextComment>(CXC);
   if (!TC)
     return cxstring::createNull();
if (!HTC)
     return cxstring::createNull();
 
   return cxstring::createRef(HTC->getTagName());
 }
 
 unsigned clang_HTMLStartTagComment_isSelfClosing(CXComment CXC) {
   const HTMLStartTagComment *HST = getASTNodeAs<HTMLStartTagComment>(CXC);
   if (!HST)
-    return false;
+    return 0;
 
   return HST->isSelfClosing();
 }
 
 unsigned clang_HTMLStartTag_getNumAttrs(CXComment CXC) {
   const HTMLStartTagComment *HST = getASTNodeAs<HTMLStartTagComment>(CXC);
   if (!HST)
     return 0;
if (!PCC || !PCC->hasParamName())
     return cxstring::createNull();
 
   return cxstring::createRef(PCC->getParamNameAsWritten());
 }
 
 unsigned clang_ParamCommandComment_isParamIndexValid(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC)
-    return false;
+    return 0;
 
   return PCC->isParamIndexValid();
 }
 
 unsigned clang_ParamCommandComment_getParamIndex(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC || !PCC->isParamIndexValid() || PCC->isVarArgParam())
     return ParamCommandComment::InvalidParamIndex;
 
   return PCC->getParamIndex();
 }
 
 unsigned clang_ParamCommandComment_isDirectionExplicit(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC)
-    return false;
+    return 0;
 
   return PCC->isDirectionExplicit();
 }
 
 enum CXCommentParamPassDirection clang_ParamCommandComment_getDirection(
                                                             CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC)
if (!TPCC || !TPCC->hasParamName())
     return cxstring::createNull();
 
   return cxstring::createRef(TPCC->getParamNameAsWritten());
 }
 
 unsigned clang_TParamCommandComment_isParamPositionValid(CXComment CXC) {
   const TParamCommandComment *TPCC = getASTNodeAs<TParamCommandComment>(CXC);
   if (!TPCC)
-    return false;
+    return 0;
 
   return TPCC->isPositionValid();
 }
 
 unsigned clang_TParamCommandComment_getDepth(CXComment CXC) {
   const TParamCommandComment *TPCC = getASTNodeAs<TParamCommandComment>(CXC);
   if (!TPCC || !TPCC->isPositionValid())
     return 0;

tools/libclang/CXCursor.cpp

   const Expr *E = nullptr;
   if (clang_isExpression(C.kind))
     E = getCursorExpr(C);
   if (!E)
     return 0;
 
   if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
     if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
-      return false;
+      return 0;
     if (auto *RecE = dyn_cast<ObjCMessageExpr>(
             MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
       if (RecE->getMethodFamily() == OMF_alloc)
-        return false;
+        return 0;
     }
-    return true;
+    return 1;
   }
 
   const MemberExpr *ME = nullptr;
   if (isa<MemberExpr>(E))
     ME = cast<MemberExpr>(E);
   else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
     ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
 

tools/libclang/CXIndexDataConsumer.cpp

void CXIndexDataConsumer::importedPCH(const FileEntry *File) {
   if (!CB.importedASTFile)
     return;
 
   CXIdxImportedASTFileInfo Info = {
                                     static_cast<CXFile>(
                                       const_cast<FileEntry *>(File)),
                                     /*module=*/nullptr,
                                     getIndexLoc(SourceLocation()),
-                                    /*isImplicit=*/false
+                                    /*isImplicit=*/0
                                   };
   CXIdxClientASTFile astFile = CB.importedASTFile(ClientData, &Info);
   (void)astFile;
 }
 
 void CXIndexDataConsumer::startedTranslationUnit() {
   CXIdxClientContainer idxCont = nullptr;
   if (CB.startedTranslationUnit)

tools/libclang/CXType.cpp

CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned i) {
   return MakeCXType(A.getAsType(), GetTU(CT));
 }
 
 unsigned clang_Type_visitFields(CXType PT,
                                 CXFieldVisitor visitor,
                                 CXClientData client_data){
   CXCursor PC = clang_getTypeDeclaration(PT);
   if (clang_isInvalid(PC.kind))
-    return false;
+    return 0;
   const RecordDecl *RD =
         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
   if (!RD || RD->isInvalidDecl())
-    return false;
+    return 0;
   RD = RD->getDefinition();
   if (!RD || RD->isInvalidDecl())
-    return false;
+    return 0;
 
   for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
        I != E; ++I){
     const FieldDecl *FD = dyn_cast_or_null<FieldDecl>((*I));
     // Callback to the client.
     switch (visitor(cxcursor::MakeCXCursor(FD, GetTU(PT)), client_data)){
     case CXVisit_Break:
-      return true;
+      return 1;
     case CXVisit_Continue:
       break;
     }
   }
-  return true;
+  return 1;
 }
 
 unsigned clang_Cursor_isAnonymous(CXCursor C){
   if (!clang_isDeclaration(C.kind))
     return 0;
   const Decl *D = cxcursor::getCursorDecl(C);
   if (const RecordDecl *FD = dyn_cast_or_null<RecordDecl>(D))
     return FD->isAnonymousStructOrUnion();
   return 0;
 }
 
 } // end: extern "C"

tools/libclang/Indexing.cpp

for (auto &UF : unsaved_files) {
     CInvok->getPreprocessorOpts().addRemappedFile(UF.Filename, MB.get());
     BufOwner->push_back(std::move(MB));
   }
 
   // Since libclang is primarily used by batch tools dealing with
   // (often very broken) source code, where spell-checking can have a
   // significant negative impact on performance (particularly when 
   // precompiled headers are involved), we disable it.
-  CInvok->getLangOpts()->SpellChecking = false;
+  CInvok->getLangOpts()->SpellChecking = 0;
 
   if (index_options & CXIndexOpt_SuppressWarnings)
-    CInvok->getDiagnosticOpts().IgnoreWarnings = true;
+    CInvok->getDiagnosticOpts().IgnoreWarnings = 1;
 
   // Make sure to use the raw module format.
   CInvok->getHeaderSearchOpts().ModuleFormat =
     CXXIdx->getPCHContainerOperations()->getRawReader().getFormat();
 
   ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags, CaptureDiagnostics,
                                   /*UserFilesAreVolatile=*/true);
   if (!Unit)
     return CXError_InvalidArguments;
 
   std::unique_ptr<CXTUOwner> CXTU(
       new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
 
   // Recover resources if we crash before exiting this method.
   llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
     CXTUCleanup(CXTU.get());
 
   // Enable the skip-parsed-bodies optimization only for C++; this may be
   // revisited.
   bool SkipBodies = (index_options & CXIndexOpt_SkipParsedBodiesInSession) &&
       CInvok->getLangOpts()->CPlusPlus;
   if (SkipBodies)
-    CInvok->getFrontendOpts().SkipFunctionBodies = true;
+    CInvok->getFrontendOpts().SkipFunctionBodies = 1;
 
   auto DataConsumer =
     std::make_shared<CXIndexDataConsumer>(client_data, CB, index_options,
                                           CXTU->getTU());
   auto InterAction = llvm::make_unique<IndexingFrontendAction>(DataConsumer,
                          SkipBodies ? IdxSession->SkipBodyData.get() : nullptr);
   std::unique_ptr<FrontendAction> IndexAction;
   IndexAction = createIndexingAction(DataConsumer,
if (requestedToGetTU) {
     CreatePreambleOnFirstParse =
         TU_options & CXTranslationUnit_CreatePreambleOnFirstParse;
     // FIXME: Add a flag for modules.
     CacheCodeCompletionResults
       = TU_options & CXTranslationUnit_CacheCompletionResults;
   }
 
   if (TU_options & CXTranslationUnit_DetailedPreprocessingRecord) {
-    PPOpts.DetailedRecord = true;
+    PPOpts.DetailedRecord = 1;
   }
 
   if (!requestedToGetTU && !CInvok->getLangOpts()->Modules)
-    PPOpts.DetailedRecord = false;
+    PPOpts.DetailedRecord = 0;
 
   // Unless the user specified that they want the preamble on the first parse
   // set it up to be created on the first reparse. This makes the first parse
   // faster, trading for a slower (first) reparse.
   unsigned PrecompilePreambleAfterNParses =
       !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
   DiagnosticErrorTrap DiagTrap(*Diags);
   bool Success = ASTUnit::LoadFromCompilerInvocationAction(

unittests/AST/DeclPrinterTest.cpp

 using namespace clang;
 using namespace ast_matchers;
 using namespace tooling;
 
 namespace {
 
 void PrintDecl(raw_ostream &Out, const ASTContext *Context, const Decl *D) {
   PrintingPolicy Policy = Context->getPrintingPolicy();
-  Policy.TerseOutput = true;
+  Policy.TerseOutput = 1;
   D->print(Out, Policy, /*Indentation*/ 0, /*PrintInstantiation*/ false);
 }
 
 class PrintMatch : public MatchFinder::MatchCallback {
   SmallString<1024> Printed;
   unsigned NumFoundDecls;
 
 public:

unittests/Frontend/FrontendActionTest.cpp

TEST(ASTFrontendAction, IncrementalParsing) {
   ASSERT_TRUE(compiler.ExecuteAction(test_action));
   ASSERT_EQ(2U, test_action.decl_names.size());
   EXPECT_EQ("main", test_action.decl_names[0]);
   EXPECT_EQ("x", test_action.decl_names[1]);
 }
 
 TEST(ASTFrontendAction, LateTemplateIncrementalParsing) {
   CompilerInvocation *invocation = new CompilerInvocation;
-  invocation->getLangOpts()->CPlusPlus = true;
-  invocation->getLangOpts()->DelayedTemplateParsing = true;
+  invocation->getLangOpts()->CPlusPlus = 1;
+  invocation->getLangOpts()->DelayedTemplateParsing = 1;
   invocation->getPreprocessorOpts().addRemappedFile(
     "test.cc", MemoryBuffer::getMemBuffer(
       "template<typename T> struct A { A(T); T data; };\n"
       "template<typename T> struct B: public A<T> {\n"
       "  B();\n"
       "  B(B const& b): A<T>(b.data) {}\n"
       "};\n"
       "B<char> c() { return B<char>(); }\n").release());

unittests/Tooling/ToolingTest.cpp

bool shouldSkipFunctionBody(Decl *D) override {
     FunctionDecl *F = dyn_cast<FunctionDecl>(D);
     return F && F->getNameAsString() == "skipMe";
   }
 };
 
 struct SkipBodyAction : public clang::ASTFrontendAction {
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
                                                  StringRef) override {
-    Compiler.getFrontendOpts().SkipFunctionBodies = true;
+    Compiler.getFrontendOpts().SkipFunctionBodies = 1;
     return llvm::make_unique<SkipBodyConsumer>();
   }
 };
 
 TEST(runToolOnCode, TestSkipFunctionBody) {
   EXPECT_TRUE(runToolOnCode(new SkipBodyAction,
                             "int skipMe() { an_error_here }"));
   EXPECT_FALSE(runToolOnCode(new SkipBodyAction,

unittests/libclang/LibclangTest.cpp

const char *contents =
       "          'external-contents': \"/real/foo.h\"\n"
       "        }\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}\n";
   TestVFO T(contents);
   T.map("/path/virtual/foo.h", "/real/foo.h");
-  clang_VirtualFileOverlay_setCaseSensitivity(T.VFO, false);
+  clang_VirtualFileOverlay_setCaseSensitivity(T.VFO, 0);
 }
 
 TEST(libclang, VirtualFileOverlay_SharedPrefix) {
   const char *contents =
       "{\n"
       "  'version': 0,\n"
       "  'roots': [\n"
       "    {\n"