Fix some typos in comments: evalute -> evaluate (NFC)

[SuperSodaSea]

Add more context in patch.

[SuperSodaSea]

Update patch.

[SuperSodaSea]

Update patch.

[SuperSodaSea]

I don't have commit access, so if anyone could help commit this patch for me, I would appreciate it.

[SuperSodaSea]

(Moved to https://github.com/llvm/llvm-project/pull/65906.)

clang/include/clang/AST/Expr.h

public:
   /// isPotentialConstantExpr - Return true if this function's definition
   /// might be usable in a constant expression in C++11, if it were marked
   /// constexpr. Return false if the function can never produce a constant
   /// expression, along with diagnostics describing why not.
   static bool isPotentialConstantExpr(const FunctionDecl *FD,
                                       SmallVectorImpl<
                                         PartialDiagnosticAt> &Diags);
 
-  /// isPotentialConstantExprUnevaluted - Return true if this expression might
+  /// isPotentialConstantExprUnevaluated - Return true if this expression might
   /// be usable in a constant expression in C++11 in an unevaluated context, if
   /// it were in function FD marked constexpr. Return false if the function can
   /// never produce a constant expression, along with diagnostics describing
   /// why not.
   static bool isPotentialConstantExprUnevaluated(Expr *E,
                                                  const FunctionDecl *FD,
                                                  SmallVectorImpl<
                                                    PartialDiagnosticAt> &Diags);

clang/lib/Serialization/ASTWriter.cpp

if (!Init) {
     return;
   }
 
   uint64_t Val = 1;
   if (EvaluatedStmt *ES = VD->getEvaluatedStmt()) {
     Val |= (ES->HasConstantInitialization ? 2 : 0);
     Val |= (ES->HasConstantDestruction ? 4 : 0);
     APValue *Evaluated = VD->getEvaluatedValue();
-    // If the evaluted result is constant, emit it.
+    // If the evaluated result is constant, emit it.
     if (Evaluated && (Evaluated->isInt() || Evaluated->isFloat()))
       Val |= 8;
   }
   push_back(Val);
   if (Val & 8) {
     AddAPValue(*VD->getEvaluatedValue());
   }
 

flang/include/flang/Lower/Support/Utils.h

A flatZip(const A &container1, const A &container2) {
   }
   return result;
 }
 
 namespace Fortran::lower {
 // Fortran::evaluate::Expr are functional values organized like an AST. A
 // Fortran::evaluate::Expr is meant to be moved and cloned. Using the front end
 // tools can often cause copies and extra wrapper classes to be added to any
-// Fortran::evalute::Expr. These values should not be assumed or relied upon to
+// Fortran::evaluate::Expr. These values should not be assumed or relied upon to
 // have an *object* identity. They are deeply recursive, irregular structures
 // built from a large number of classes which do not use inheritance and
 // necessitate a large volume of boilerplate code as a result.
 //
 // Contrastingly, LLVM data structures make ubiquitous assumptions about an
 // object's identity via pointers to the object. An object's location in memory
 // is thus very often an identifying relation.
 

flang/lib/Evaluate/shape.cpp

auto GetShapeHelper::operator()(const ProcedureRef &call) const -> Result {
   return Shape(static_cast<std::size_t>(call.Rank()), MaybeExtentExpr{});
 }
 
 void GetShapeHelper::AccumulateExtent(
     ExtentExpr &result, ExtentExpr &&n) const {
   result = std::move(result) + std::move(n);
   if (context_) {
     // Fold during expression creation to avoid creating an expression so
-    // large we can't evalute it without overflowing the stack.
+    // large we can't evaluate it without overflowing the stack.
     result = Fold(*context_, std::move(result));
   }
 }
 
 // Check conformance of the passed shapes.
 std::optional<bool> CheckConformance(parser::ContextualMessages &messages,
     const Shape &left, const Shape &right, CheckConformanceFlags::Flags flags,
     const char *leftIs, const char *rightIs) {

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

InterfaceMethod<
       /*retTy=*/"Block::BlockArgListType",
       /*methodName=*/"getRegionInputArgs",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
-        // TODO: reevalute the need for a cast when a better mechanism exists.
+        // TODO: reevaluate the need for a cast when a better mechanism exists.
         return getBlock()->getArguments().take_front(
             cast<DestinationStyleOpInterface>(*this->getOperation())
                 .getNumDpsInputs());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the output block arguments of the region.
       }],
       /*retTy=*/"Block::BlockArgListType",
       /*methodName=*/"getRegionOutputArgs",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
-        // TODO: reevalute the need for a cast when a better mechanism exists.
+        // TODO: reevaluate the need for a cast when a better mechanism exists.
         return getBlock()->getArguments().take_back(
             cast<DestinationStyleOpInterface>(*this->getOperation())
                 .getNumDpsInits());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the `opOperand` shape or an empty vector for scalars.
InterfaceMethod<
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(result.getOwner() == this->getOperation());
         auto indexingMaps =
           $_op.getIndexingMaps().template getAsValueRange<AffineMapAttr>();
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
-        // TODO: reevalute the need for a cast when a better mechanism exists.
+        // TODO: reevaluate the need for a cast when a better mechanism exists.
         return *(indexingMaps.begin() +
                  cast<DestinationStyleOpInterface>(*this->getOperation())
                      .getNumDpsInputs() +
                  result.getResultNumber());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the value yielded by the region corresponding to an output
         `opOperand`.
       }],
       /*retTy=*/"OpOperand *",
       /*methodName=*/"getMatchingYieldValue",
       /*args=*/(ins "OpOperand*":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == this->getOperation());
         // MLIR currently does not support dependent interfaces or interface
         // inheritance. By construction all ops with StructuredOpInterface must
         // implement DestinationStyleOpInterface.
-        // TODO: reevalute the need for a cast when a better mechanism exists.
+        // TODO: reevaluate the need for a cast when a better mechanism exists.
         int64_t resultIndex =
             opOperand->getOperandNumber() -
             cast<DestinationStyleOpInterface>(*this->getOperation())
                 .getNumDpsInputs();
         assert(resultIndex >= 0 &&
                resultIndex < this->getOperation()->getNumResults());
         Operation *yieldOp = getBlock()->getTerminator();
         return &yieldOp->getOpOperand(resultIndex);
let extraClassDeclaration = [{
     int64_t getIndexingMapIndex(OpOperand *opOperand);
 
     //========================================================================//
     // Forwarding functions to access interface methods from the
     // DestinationStyleOpInterface.
     // MLIR currently does not support dependent interfaces or interface
     // inheritance. By construction all ops with StructuredOpInterface must
     // implement DestinationStyleOpInterface.
-    // TODO: reevalute the need for a cast when a better mechanism exists.
+    // TODO: reevaluate the need for a cast when a better mechanism exists.
     //========================================================================//
 
     int64_t getNumDpsInputs() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
           .getNumDpsInputs();
     }
 
     int64_t getNumDpsInits() {

openmp/libomptarget/test/lit.cfg

for env in test_env:
         config.environment[name] = value
 
 def append_dynamic_library_path(name, value, sep):
     if name in config.environment:
         config.environment[name] = value + sep + config.environment[name]
     else:
         config.environment[name] = value
 
-# Evalute the environment variable which is a string boolean value.
+# Evaluate the environment variable which is a string boolean value.
 def evaluate_bool_env(env):
     env = env.lower()
     possible_true_values = ["on", "true", "1"]
     for v in possible_true_values:
         if env == v:
             return True
     return False