[MLIR][NFC] Rework some comments.

mlir/include/mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_
 #define MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_
 
 #include "mlir/Analysis/AliasAnalysis.h"
 
 namespace mlir {
-/// This class implements a location form of aliasing that tries to identify the
-/// underlying values addressed by each value and performs a few basic checks to
-/// see if they alias.
+/// This class implements a local form of alias analysis that tries to identify
+/// the underlying values addressed by each value and performs a few basic
+/// checks to see if they alias.
 class LocalAliasAnalysis {
 public:
   /// Given two values, return their aliasing behavior.
   AliasResult alias(Value lhs, Value rhs);
 
   /// Return the modify-reference behavior of `op` on `location`.
   ModRefResult getModRef(Operation *op, Value location);
 };
 } // end namespace mlir
 
 #endif // MLIR_ANALYSIS_ALIASANALYSIS_LOCALALIASANALYSIS_H_

mlir/include/mlir/Analysis/DataFlowAnalysis.h

 //===- DataFlowAnalysis.h - General DataFlow Analysis Utilities -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This files several utilities and algorithms that perform abstract dataflow
+// This file has several utilities and algorithms that perform abstract dataflow
 // analysis over the IR. These allow for users to hook into various analysis
 // propagation algorithms without needing to reinvent the traversal over the
 // different types of control structures present within MLIR, such as regions,
 // the callgraph, etc. A few of the main entry points are detailed below:
 //
 // FowardDataFlowAnalysis:
 //  This class provides support for defining dataflow algorithms that are
 //  forward, sparse, pessimistic (except along unreached backedges) and

mlir/include/mlir/Interfaces/ControlFlowInterfaces.h

 namespace detail {
 /// Verify that types match along control flow edges described the given op.
 LogicalResult verifyTypesAlongControlFlowEdges(Operation *op);
 } //  namespace detail
 
 /// This class represents a successor of a region. A region successor can either
 /// be another region, or the parent operation. If the successor is a region,
 /// this class represents the destination region, as well as a set of arguments
-/// from that region that will be populated by values from the current region.
+/// from that region that will be populated when control flows into the region.
 /// If the successor is the parent operation, this class represents an optional
-/// set of results that will be populated by values from the current region.
+/// set of results that will be populated when control returns to the parent
+/// operation.
 ///
 /// This interface assumes that the values from the current region that are used
 /// to populate the successor inputs are the operands of the return-like
 /// terminator operations in the blocks within this region.
 class RegionSuccessor {
 public:
   /// Initialize a successor that branches to another region of the parent
   /// operation.

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

let methods = [
     >,
     InterfaceMethod<[{
         Returns the viable successors of a region at `index`, or the possible
         successors when branching from the parent op if `index` is None. These
         are the regions that may be selected during the flow of control. If
         `index` is None, `operands` is a set of optional attributes that
         either correspond to a constant value for each operand of this
         operation, or null if that operand is not a constant. If `index` is
-        valid, `operands` corresponds to the exit values of the region at
+        valid, `operands` corresponds to the entry values of the region at
         `index`. Only a region, i.e. a valid `index`, may use the parent
         operation as a successor. This method allows for describing which
         regions may be executed when entering an operation, and which regions
         are executed after having executed another region of the parent op. The
         successor region must be non-empty.
       }],
       "void", "getSuccessorRegions",
       (ins "::mlir::Optional<unsigned>":$index, "::mlir::ArrayRef<::mlir::Attribute>":$operands,