[MLIR] Improving the Comment

[kamleshbhalui]

Summary

Fixed the misleading comment.
i.e.
Returns if ...
to
Returns true if ...

[bondhugula]

Please fix the 80 column spillovers. Although this "Returns if ..." construction is used pervasively and isn't actually incorrect, it can be a bit confusing. "if this ..." was being used as a noun for the bool value.

Please fix the commit title - it's itself broken.
Improve the Comment -> "Improve doc comments for several methods returning bools"

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

375–376

This will have to be wrapped.

mlir/include/mlir/Analysis/CallGraph.h

enum class Kind {
       // A 'Child' edge is used when the region of target node is defined inside
       // of the callable region of this node. This means that the region of this
       // node is an ancestor of the region for the target node. As such, this
       // edge cannot be used on the 'external' node.
       Child,
     };
 
   public:
-    /// Returns if this edge represents an `Abstract` edge.
+    /// Returns true if this edge represents an `Abstract` edge.
     bool isAbstract() const { return targetAndKind.getInt() == Kind::Abstract; }
 
-    /// Returns if this edge represents a `Call` edge.
+    /// Returns true if this edge represents a `Call` edge.
     bool isCall() const { return targetAndKind.getInt() == Kind::Call; }
 
-    /// Returns if this edge represents a `Child` edge.
+    /// Returns true if this edge represents a `Child` edge.
     bool isChild() const { return targetAndKind.getInt() == Kind::Child; }
 
     /// Returns the target node for this edge.
     CallGraphNode *getTarget() const { return targetAndKind.getPointer(); }
 
     bool operator==(const Edge &edge) const {
       return targetAndKind == edge.targetAndKind;
     }
 
   private:
     Edge(CallGraphNode *node, Kind kind) : targetAndKind(node, kind) {}
     explicit Edge(llvm::PointerIntPair<CallGraphNode *, 2, Kind> targetAndKind)
         : targetAndKind(targetAndKind) {}
 
     /// The target node of this edge, as well as the edge kind.
     llvm::PointerIntPair<CallGraphNode *, 2, Kind> targetAndKind;
 
     // Provide access to the constructor and Kind.
     friend class CallGraphNode;
   };
 
-  /// Returns if this node is the external node.
+  /// Returns true if this node is an external node.
   bool isExternal() const;
 
   /// Returns the callable region this node represents. This can only be called
   /// on non-external nodes.
   Region *getCallableRegion() const;
 
   /// Adds an abstract reference edge to the given node. An abstract edge does
   /// not come from any observable operations, so this is only valid on the

mlir/include/mlir/Dialect/Affine/IR/AffineOps.h

 void fullyComposeAffineMapAndOperands(AffineMap *map,
                                       SmallVectorImpl<Value> *operands);
 
 #include "mlir/Dialect/Affine/IR/AffineOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Affine/IR/AffineOps.h.inc"
 
-/// Returns if the provided value is the induction variable of a AffineForOp.
+/// Returns true if the provided value is the induction variable of a
+/// AffineForOp.
 bool isForInductionVar(Value val);
 
 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.
 AffineForOp getForInductionVarOwner(Value val);
 
 /// Extracts the induction variables from a list of AffineForOps and places them
 /// in the output argument `ivs`.

mlir/include/mlir/IR/Attributes.h

public:
   public:
     using reference = std::complex<APFloat>;
   };
 
   //===--------------------------------------------------------------------===//
   // Value Querying
   //===--------------------------------------------------------------------===//
 
-  /// Returns if this attribute corresponds to a splat, i.e. if all element
+  /// Returns true if this attribute corresponds to a splat, i.e. if all element
   /// values are the same.
   bool isSplat() const;
 
   /// Return the splat value for this attribute. This asserts that the attribute
   /// corresponds to a splat.
   Attribute getSplatValue() const { return getSplatValue<Attribute>(); }
   template <typename T>
   typename std::enable_if<!std::is_base_of<Attribute, T>::value ||

mlir/include/mlir/IR/Diagnostics.h

public:
   operator LogicalResult() const;
 
 private:
   InFlightDiagnostic &operator=(const InFlightDiagnostic &) = delete;
   InFlightDiagnostic &operator=(InFlightDiagnostic &&) = delete;
   InFlightDiagnostic(DiagnosticEngine *owner, Diagnostic &&rhs)
       : owner(owner), impl(std::move(rhs)) {}
 
-  /// Returns if the diagnostic is still active, i.e. it has a live diagnostic.
+  /// Returns true if the diagnostic is still active, i.e. it has a live
+  /// diagnostic.
   bool isActive() const { return impl.hasValue(); }
 
-  /// Returns if the diagnostic is still in flight to be reported.
+  /// Returns true if the diagnostic is still in flight to be reported.
   bool isInFlight() const { return owner; }
 
   // Allow access to the constructor.
   friend DiagnosticEngine;
 
   /// The engine that this diagnostic is to report to.
   DiagnosticEngine *owner = nullptr;
 

mlir/include/mlir/IR/Operation.h

TerminatorStatus getTerminatorStatus() {
     if (auto *absOp = getAbstractOperation()) {
       return absOp->hasProperty(OperationProperty::Terminator)
                  ? TerminatorStatus::Terminator
                  : TerminatorStatus::NonTerminator;
     }
     return TerminatorStatus::Unknown;
   }
 
-  /// Returns if the operation is known to be a terminator.
+  /// Returns true if the operation is known to be a terminator.
   bool isKnownTerminator() {
     return getTerminatorStatus() == TerminatorStatus::Terminator;
   }
 
-  /// Returns if the operation is known to *not* be a terminator.
+  /// Returns true if the operation is known to *not* be a terminator.
   bool isKnownNonTerminator() {
     return getTerminatorStatus() == TerminatorStatus::NonTerminator;
   }
 
   /// Returns true if the operation is known to be completely isolated from
   /// enclosing regions, i.e., no internal regions reference values defined
   /// above this operation.
   bool isKnownIsolatedFromAbove() {
     if (auto *absOp = getAbstractOperation())
       return absOp->hasProperty(OperationProperty::IsolatedFromAbove);
     return false;
   }
 
   /// Attempt to fold this operation with the specified constant operand values
   /// - the elements in "operands" will correspond directly to the operands of
   /// the operation, but may be null if non-constant. If folding is successful,
   /// this fills in the `results` vector. If not, `results` is unspecified.
   LogicalResult fold(ArrayRef<Attribute> operands,
                      SmallVectorImpl<OpFoldResult> &results);
 
-  /// Returns if the operation was registered with a particular trait, e.g.
+  /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
   template <template <typename T> class Trait> bool hasTrait() {
     auto *absOp = getAbstractOperation();
     return absOp ? absOp->hasTrait<Trait>() : false;
   }
 
   //===--------------------------------------------------------------------===//
   // Operation Walkers

mlir/include/mlir/IR/OperationSupport.h

public:
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this operation, null otherwise. This should not be used
   /// directly.
   template <typename T> typename T::Concept *getInterface() const {
     return interfaceMap.lookup<T>();
   }
 
-  /// Returns if the operation has a particular trait.
+  /// Returns true if the operation has a particular trait.
   template <template <typename T> class Trait> bool hasTrait() const {
     return hasRawTrait(TypeID::get<Trait>());
   }
 
   /// Look up the specified operation in the specified MLIRContext and return a
   /// pointer to it if present.  Otherwise, return a null pointer.
   static const AbstractOperation *lookup(StringRef opName,
                                          MLIRContext *context);

mlir/include/mlir/IR/Visitors.h

public:
   WalkResult(Diagnostic &&) : result(Interrupt) {}
   WalkResult(InFlightDiagnostic &&) : result(Interrupt) {}
 
   bool operator==(const WalkResult &rhs) const { return result == rhs.result; }
 
   static WalkResult interrupt() { return {Interrupt}; }
   static WalkResult advance() { return {Advance}; }
 
-  /// Returns if the walk was interrupted.
+  /// Returns true if the walk was interrupted.
   bool wasInterrupted() const { return result == Interrupt; }
 };
 
 namespace detail {
 /// Helper templates to deduce the first argument of a callback parameter.
 template <typename Ret, typename Arg> Arg first_argument_type(Ret (*)(Arg));
 template <typename Ret, typename F, typename Arg>
 Arg first_argument_type(Ret (F::*)(Arg));

mlir/include/mlir/Interfaces/SideEffectInterfaces.td

let extraClassDeclaration = [{
     template <typename Effect> bool hasEffect() {
       SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return llvm::any_of(effects, [](const auto &it) {
         return llvm::isa<Effect>(it.getEffect());
       });
     }
 
-    /// Returns if this operation only has the given effect.
+    /// Returns true if this operation only has the given effect.
     template <typename Effect> bool onlyHasEffect() {
       SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return !effects.empty() && llvm::all_of(effects, [](const auto &it) {
         return isa<Effect>(it.getEffect());
       });
     }
 
-    /// Returns if this operation has no effects.
+    /// Returns true if this operation has no effects.
     bool hasNoEffect() {
       SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return effects.empty();
     }
 
-    /// Returns if the given operation has no effects for this interface.
+    /// Returns true if the given operation has no effects for this interface.
     static bool hasNoEffect(Operation *op) {
       if (auto interface = dyn_cast<}] # name # [{>(op))
         return interface.hasNoEffect();
       return op->hasTrait<OpTrait::HasRecursiveSideEffects>();
     }
   }];
 
   // The base effect name of this interface.

mlir/include/mlir/Pass/AnalysisManager.h

public:
   }
   template <typename AnalysisT, typename AnalysisT2, typename... OtherAnalysesT>
   void preserve() {
     preserve<AnalysisT>();
     preserve<AnalysisT2, OtherAnalysesT...>();
   }
   void preserve(TypeID id) { preservedIDs.insert(id); }
 
-  /// Returns if the given analysis has been marked as preserved. Note that this
-  /// simply checks for the presence of a given analysis ID and should not be
-  /// used as a general preservation checker.
+  /// Returns true if the given analysis has been marked as preserved. Note that
+  /// this simply checks for the presence of a given analysis ID and should not
+  /// be used as a general preservation checker.
   template <typename AnalysisT> bool isPreserved() const {
     return isPreserved(TypeID::get<AnalysisT>());
   }
   bool isPreserved(TypeID id) const { return preservedIDs.count(id); }
 
 private:
   /// The set of analyses that are known to be preserved.
   SmallPtrSet<TypeID, 2> preservedIDs;

mlir/include/mlir/TableGen/Dialect.h

public:
 
   // Returns the list of dialect (class names) that this dialect depends on.
   // These are dialects that will be loaded on construction of this dialect.
   ArrayRef<StringRef> getDependentDialects() const;
 
   // Returns the dialects extra class declaration code.
   llvm::Optional<StringRef> getExtraClassDeclaration() const;
 
-  // Returns if this dialect has a constant materializer or not.
+  // Returns true if this dialect has a constant materializer.
   bool hasConstantMaterializer() const;
 
-  /// Returns if this dialect has an operation attribute verifier.
+  /// Returns true if this dialect has an operation attribute verifier.
   bool hasOperationAttrVerify() const;
 
-  /// Returns if this dialect has a region argument attribute verifier.
+  /// Returns true if this dialect has a region argument attribute verifier.
   bool hasRegionArgAttrVerify() const;
 
-  /// Returns if this dialect has a region result attribute verifier.
+  /// Returns true if this dialect has a region result attribute verifier.
   bool hasRegionResultAttrVerify() const;
 
   // Returns whether two dialects are equal by checking the equality of the
   // underlying record.
   bool operator==(const Dialect &other) const;
 
   // Compares two dialects by comparing the names of the dialects.
   bool operator<(const Dialect &other) const;

mlir/lib/Analysis/CallGraph.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // CallGraphNode
 //===----------------------------------------------------------------------===//
 
-/// Returns if this node refers to the indirect/external node.
+/// Returns true if this node refers to the indirect/external node.
 bool CallGraphNode::isExternal() const { return !callableRegion; }
 
 /// Return the callable region this node represents. This can only be called
 /// on non-external nodes.
 Region *CallGraphNode::getCallableRegion() const {
   assert(!isExternal() && "the external node has no callable region");
   return callableRegion;
 }

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 }
 
 LogicalResult AffineForOp::moveOutOfLoop(ArrayRef<Operation *> ops) {
   for (auto *op : ops)
     op->moveBefore(*this);
   return success();
 }
 
-/// Returns if the provided value is the induction variable of a AffineForOp.
+/// Returns true if the provided value is the induction variable of a
+/// AffineForOp.
 bool mlir::isForInductionVar(Value val) {
   return getForInductionVarOwner(val) != AffineForOp();
 }
 
 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.
 AffineForOp mlir::getForInductionVarOwner(Value val) {
   auto ivArg = val.dyn_cast<BlockArgument>();

mlir/lib/IR/AsmPrinter.cpp

if (printerFlags.shouldPrintDebugInfoPrettyForm()) {
     printLocationInternal(loc, /*pretty=*/true);
   } else {
     os << "loc(";
     printLocationInternal(loc);
     os << ')';
   }
 }
 
-/// Returns if the given dialect symbol data is simple enough to print in the
-/// pretty form, i.e. without the enclosing "".
+/// Returns true if the given dialect symbol data is simple enough to print in
+/// the pretty form, i.e. without the enclosing "".
 static bool isDialectSymbolSimpleEnoughForPrettyForm(StringRef symName) {
   // The name must start with an identifier.
   if (symName.empty() || !isalpha(symName.front()))
     return false;
 
   // Ignore all the characters that are valid in an identifier in the symbol
   // name.
   symName = symName.drop_while(
if (isDialectSymbolSimpleEnoughForPrettyForm(symString)) {
     os << '.' << symString;
     return;
   }
 
   // TODO: escape the symbol name, it could contain " characters.
   os << "<\"" << symString << "\">";
 }
 
-/// Returns if the given string can be represented as a bare identifier.
+/// Returns true if the given string can be represented as a bare identifier.
 static bool isBareIdentifier(StringRef name) {
   assert(!name.empty() && "invalid name");
 
   // By making this unsigned, the value passed in to isalnum will always be
   // in the range 0-255. This is important when building with MSVC because
   // its implementation will assert. This situation can arise when dealing
   // with UTF-8 multibyte characters.
   unsigned char firstChar = static_cast<unsigned char>(name[0]);

mlir/lib/IR/Attributes.cpp

static APInt readBits(const char *rawData, size_t bitPos, size_t bitWidth) {
 
   // Otherwise, the bit position must be 8-bit aligned.
   assert((bitPos % CHAR_BIT) == 0 && "expected bitPos to be 8-bit aligned");
   APInt result(bitWidth, 0);
   writeAPInt(rawData + (bitPos / CHAR_BIT), bitWidth, result);
   return result;
 }
 
-/// Returns if 'values' corresponds to a splat, i.e. one element, or has the
-/// same element count as 'type'.
+/// Returns true if 'values' corresponds to a splat, i.e. one element, or has
+/// the same element count as 'type'.
 template <typename Values>
 static bool hasSameElementsOrSplat(ShapedType type, const Values &values) {
   return (values.size() == 1) ||
          (type.getNumElements() == static_cast<int64_t>(values.size()));
 }
 
 //===----------------------------------------------------------------------===//
 // DenseElementAttr Iterators

 /// the current attribute.
 bool DenseElementsAttr::isValidComplex(int64_t dataEltSize, bool isInt,
                                        bool isSigned) const {
   return ::isValidIntOrFloat(
       getType().getElementType().cast<ComplexType>().getElementType(),
       dataEltSize / 2, isInt, isSigned);
 }
 
-/// Returns if this attribute corresponds to a splat, i.e. if all element
+/// Returns true if this attribute corresponds to a splat, i.e. if all element
 /// values are the same.
 bool DenseElementsAttr::isSplat() const {
   return static_cast<DenseElementsAttributeStorage *>(impl)->isSplat;
 }
 
 /// Return the held element values as a range of Attributes.
 auto DenseElementsAttr::getAttributeValues() const
     -> llvm::iterator_range<AttributeElementIterator> {

mlir/lib/Parser/DialectSymbolParser.cpp

if (!parser.getToken().is(Token::string))
       return failure();
 
     if (string)
       *string = parser.getTokenSpelling().drop_front().drop_back();
     parser.consumeToken();
     return success();
   }
 
-  /// Returns if the current token corresponds to a keyword.
+  /// Returns true if the current token corresponds to a keyword.
   bool isCurrentTokenAKeyword() const {
     return parser.getToken().is(Token::bare_identifier) ||
            parser.getToken().isKeyword();
   }
 
   /// Parse the given keyword if present.
   ParseResult parseOptionalKeyword(StringRef keyword) override {
     // Check that the current token has the same spelling.

mlir/lib/Parser/Parser.cpp

public:
   ParseResult printIntegerSet(IntegerSet &set) override {
     return parser.parseIntegerSetReference(set);
   }
 
   //===--------------------------------------------------------------------===//
   // Identifier Parsing
   //===--------------------------------------------------------------------===//
 
-  /// Returns if the current token corresponds to a keyword.
+  /// Returns true if the current token corresponds to a keyword.
   bool isCurrentTokenAKeyword() const {
     return parser.getToken().is(Token::bare_identifier) ||
            parser.getToken().isKeyword();
   }
 
   /// Parse the given keyword if present.
   ParseResult parseOptionalKeyword(StringRef keyword) override {
     // Check that the current token has the same spelling.

mlir/lib/Transforms/DialectConversion.cpp

 /// This class defines a recursive operation legalizer.
 class OperationLegalizer {
 public:
   using LegalizationAction = ConversionTarget::LegalizationAction;
 
   OperationLegalizer(ConversionTarget &targetInfo,
                      const OwningRewritePatternList &patterns);
 
-  /// Returns if the given operation is known to be illegal on the target.
+  /// Returns true if the given operation is known to be illegal on the target.
   bool isIllegal(Operation *op) const;
 
   /// Attempt to legalize the given operation. Returns success if the operation
   /// was legalized, failure otherwise.
   LogicalResult legalize(Operation *op, ConversionPatternRewriter &rewriter);
 
   /// Returns the conversion target in use by the legalizer.
   ConversionTarget &getTarget() { return target; }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

struct OperationFormat {
   /// The index of the buildable type, if valid, for every operand and result.
   std::vector<TypeResolution> operandTypes, resultTypes;
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // Parser Gen
 
-/// Returns if we can format the given attribute as an EnumAttr in the parser
-/// format.
+/// Returns true if we can format the given attribute as an EnumAttr in the
+/// parser format.
 static bool canFormatEnumAttr(const NamedAttribute *attr) {
   const EnumAttr *enumAttr = dyn_cast<EnumAttr>(&attr->attr);
   if (!enumAttr)
     return false;
 
   // The attribute must have a valid underlying type and a constant builder.
   return !enumAttr->getUnderlyingType().empty() &&
          !enumAttr->getConstBuilderTemplate().empty();