run formatter

Signed-off-by: Justin Stitt <[email protected]>

Author: JustinStitt

clang/include/clang/AST/ASTContext.h

@@ -2659,7 +2659,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
   };
 
   /// Check overflow behavior type compatibility for assignments.
-  /// Returns detailed information about OBT compatibility for assignment checking.
+  /// Returns detailed information about OBT compatibility for assignment
+  /// checking.
   OBTAssignResult checkOBTAssignmentCompatibility(QualType LHS, QualType RHS);
 
   /// Return true if the given types are an RISC-V vector builtin type and a

clang/include/clang/Basic/DiagnosticGroups.td

@@ -138,7 +138,8 @@ def ImplicitOverflowBehaviorConversionAssignmentPedantic
 def ImplicitOverflowBehaviorConversionAtFunctionBoundary
     : DiagGroup<"implicit-overflow-behavior-conversion-function-boundary">;
 def ImplicitOverflowBehaviorConversionAtFunctionBoundaryPedantic
-    : DiagGroup<"implicit-overflow-behavior-conversion-function-boundary-pedantic">;
+    : DiagGroup<
+          "implicit-overflow-behavior-conversion-function-boundary-pedantic">;
 def ImplicitOverflowBehaviorConversionPedantic
     : DiagGroup<"implicit-overflow-behavior-conversion-pedantic">;
 def ImplicitOverflowBehaviorConversion

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9211,20 +9211,21 @@ def ext_typecheck_convert_discards_qualifiers : ExtWarn<
   "|%diff{casting $ to type $|casting between types}0,1}2"
   " discards qualifiers">,
   InGroup<IncompatiblePointerTypesDiscardsQualifiers>;
-def ext_typecheck_convert_discards_overflow_behavior : ExtWarn<
-  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
-  "|%diff{passing $ to parameter of type $|"
-  "passing to parameter of different type}0,1"
-  "|%diff{returning $ from a function with result type $|"
-  "returning from function with different return type}0,1"
-  "|%diff{converting $ to type $|converting between types}0,1"
-  "|%diff{initializing $ with an expression of type $|"
-  "initializing with expression of different type}0,1"
-  "|%diff{sending $ to parameter of type $|"
-  "sending to parameter of different type}0,1"
-  "|%diff{casting $ to type $|casting between types}0,1}2"
-  " discards overflow behavior">,
-  InGroup<IncompatiblePointerTypesDiscardsOverflowBehavior>;
+def ext_typecheck_convert_discards_overflow_behavior
+    : ExtWarn<
+          "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+          "|%diff{passing $ to parameter of type $|"
+          "passing to parameter of different type}0,1"
+          "|%diff{returning $ from a function with result type $|"
+          "returning from function with different return type}0,1"
+          "|%diff{converting $ to type $|converting between types}0,1"
+          "|%diff{initializing $ with an expression of type $|"
+          "initializing with expression of different type}0,1"
+          "|%diff{sending $ to parameter of type $|"
+          "sending to parameter of different type}0,1"
+          "|%diff{casting $ to type $|casting between types}0,1}2"
+          " discards overflow behavior">,
+      InGroup<IncompatiblePointerTypesDiscardsOverflowBehavior>;
 def err_typecheck_convert_discards_qualifiers : Error<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"

clang/lib/CodeGen/CGExprScalar.cpp

@@ -1803,16 +1803,17 @@ Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
   // capability checks as this overflow behavior kind is also capable of
   // emitting traps without runtime sanitizer support.
   // Also skip instrumentation if either source or destination has 'wrap'
-  // behavior - the user has explicitly indicated they accept wrapping semantics.
-  // Use non-canonical types to preserve OBT annotations.
+  // behavior - the user has explicitly indicated they accept wrapping
+  // semantics. Use non-canonical types to preserve OBT annotations.
   const auto *DstOBT = NoncanonicalDstType->getAs<OverflowBehaviorType>();
   const auto *SrcOBT = NoncanonicalSrcType->getAs<OverflowBehaviorType>();
   bool OBTrapInvolved =
       (DstOBT && DstOBT->isTrapKind()) || (SrcOBT && SrcOBT->isTrapKind());
   bool OBWrapInvolved =
       (DstOBT && DstOBT->isWrapKind()) || (SrcOBT && SrcOBT->isWrapKind());
 
-  if ((Opts.EmitImplicitIntegerTruncationChecks || OBTrapInvolved) && !OBWrapInvolved)
+  if ((Opts.EmitImplicitIntegerTruncationChecks || OBTrapInvolved) &&
+      !OBWrapInvolved)
     EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
                                NoncanonicalDstType, Loc, OBTrapInvolved);
 

clang/lib/Sema/Sema.cpp

@@ -849,7 +849,8 @@ ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
                         isa<CXXFunctionalCastExpr>(E);
 
   if ((Kind == CK_IntegralCast || Kind == CK_IntegralToBoolean ||
-       (Kind == CK_NoOp && E->getType()->isIntegerType() && Ty->isIntegerType())) &&
+       (Kind == CK_NoOp && E->getType()->isIntegerType() &&
+        Ty->isIntegerType())) &&
       IsExplicitCast) {
     if (const auto *SourceOBT = E->getType()->getAs<OverflowBehaviorType>()) {
       if (Ty->isIntegerType() && !Ty->isOverflowBehaviorType()) {

clang/lib/Sema/SemaExprCXX.cpp

@@ -4685,8 +4685,8 @@ static QualType adjustVectorType(ASTContext &Context, QualType FromTy,
   return Context.getExtVectorType(ElType, FromVec->getNumElements());
 }
 
-/// Check if an integral conversion involves incompatible overflow behavior types.
-/// Returns true if the conversion is invalid.
+/// Check if an integral conversion involves incompatible overflow behavior
+/// types. Returns true if the conversion is invalid.
 static bool checkIncompatibleOBTConversion(Sema &S, QualType FromType,
                                            QualType ToType, Expr *From) {
   const auto *FromOBT = FromType->getAs<OverflowBehaviorType>();

clang/lib/Sema/SemaOverload.cpp

@@ -2874,8 +2874,7 @@ bool Sema::IsOverflowBehaviorTypeConversion(QualType FromType,
   if (FromType->isOverflowBehaviorType() && !ToType->isOverflowBehaviorType()) {
     // Don't allow implicit conversion from OverflowBehaviorType to scoped enum
     if (const EnumType *ToEnumType = ToType->getAs<EnumType>()) {
-      const EnumDecl *ToED =
-          ToEnumType->getDecl()->getDefinitionOrSelf();
+      const EnumDecl *ToED = ToEnumType->getDecl()->getDefinitionOrSelf();
       if (ToED->isScoped())
         return false;
     }