[NFC] Fix comment style in MLIR unittests to conform to LLVM coding standards.

mlir/unittests/Dialect/SPIRV/DeserializationTest.cpp

 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/MLIRContext.h"
 #include "gmock/gmock.h"
 
 #include <memory>
 
 using namespace mlir;
 
-// Load the SPIRV dialect
+/// Load the SPIRV dialect.
 static DialectRegistration<spirv::SPIRVDialect> SPIRVRegistration;
 
 using ::testing::StrEq;
 
 //===----------------------------------------------------------------------===//
 // Test Fixture
 //===----------------------------------------------------------------------===//
 
TEST_F(DeserializationTest, ZeroWordCountFailure) {
   ASSERT_FALSE(deserialize());
   expectDiagnostic("word count cannot be zero");
 }
 
 TEST_F(DeserializationTest, InsufficientWordFailure) {
   addHeader();
   binary.push_back((2u << 16) |
                    static_cast<uint32_t>(spirv::Opcode::OpTypeVoid));
-  // Missing word for type <id>
+  // Missing word for type <id>.
 
   ASSERT_FALSE(deserialize());
   expectDiagnostic("insufficient words for the last instruction");
 }
 
 //===----------------------------------------------------------------------===//
 // Types
 //===----------------------------------------------------------------------===//

 // Functions
 //===----------------------------------------------------------------------===//
 
 TEST_F(DeserializationTest, FunctionMissingEndFailure) {
   addHeader();
   auto voidType = addVoidType();
   auto fnType = addFunctionType(voidType, {});
   addFunction(voidType, fnType);
-  // Missing OpFunctionEnd
+  // Missing OpFunctionEnd.
 
   ASSERT_FALSE(deserialize());
   expectDiagnostic("expected OpFunctionEnd instruction");
 }
 
 TEST_F(DeserializationTest, FunctionMissingParameterFailure) {
   addHeader();
   auto voidType = addVoidType();
   auto i32Type = addIntType(32);
   auto fnType = addFunctionType(voidType, {i32Type});
   addFunction(voidType, fnType);
-  // Missing OpFunctionParameter
+  // Missing OpFunctionParameter.
 
   ASSERT_FALSE(deserialize());
   expectDiagnostic("expected OpFunctionParameter instruction");
 }
 
 TEST_F(DeserializationTest, FunctionMissingLabelForFirstBlockFailure) {
   addHeader();
   auto voidType = addVoidType();
   auto fnType = addFunctionType(voidType, {});
   addFunction(voidType, fnType);
-  // Missing OpLabel
+  // Missing OpLabel.
   addReturn();
   addFunctionEnd();
 
   ASSERT_FALSE(deserialize());
   expectDiagnostic("a basic block must start with OpLabel");
 }
 
 TEST_F(DeserializationTest, FunctionMalformedLabelFailure) {

mlir/unittests/SDBM/SDBMTest.cpp

 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/MLIRContext.h"
 #include "gtest/gtest.h"
 
 #include "llvm/ADT/DenseSet.h"
 
 using namespace mlir;
 
-// Load the SDBM dialect
+/// Load the SDBM dialect.
 static DialectRegistration<SDBMDialect> SDBMRegistration;
 
 static MLIRContext *ctx() {
   static thread_local MLIRContext context;
   return &context;
 }
 
 static SDBMDialect *dialect() {

mlir/unittests/TableGen/EnumsGenTest.cpp

 //===- EnumsGenTest.cpp - TableGen EnumsGen Tests -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gmock/gmock.h"
 #include <type_traits>
 
-// Pull in generated enum utility declarations
+/// Pull in generated enum utility declarations and definitions.
 #include "EnumsGenTest.h.inc"
-// And definitions
 #include "EnumsGenTest.cpp.inc"
 
-// Test namespaces and enum class/utility names
+/// Test namespaces and enum class/utility names.
 using Outer::Inner::ConvertToEnum;
 using Outer::Inner::ConvertToString;
 using Outer::Inner::StrEnum;
 
 TEST(EnumsGenTest, GeneratedStrEnumDefinition) {
   EXPECT_EQ(0u, static_cast<uint64_t>(StrEnum::CaseA));
   EXPECT_EQ(10u, static_cast<uint64_t>(StrEnum::CaseB));
 }

mlir/unittests/TableGen/FormatTest.cpp

 using ::testing::StrEq;
 
 TEST(FormatTest, EmptyFmtStr) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("", &ctx));
   EXPECT_TRUE(result.empty());
 }
 
-// Allow extra unused positional parameters
+/// Allow extra unused positional parameters.
 TEST(FormatTest, EmptyFmtStrExtraParams) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("", &ctx, "a", "b", "c"));
   EXPECT_TRUE(result.empty());
 }
 
-// Allow unused placeholder substitution in context
+/// Allow unused placeholder substitution in context.
 TEST(FormatTest, EmptyFmtStrPopulatedCtx) {
   FmtContext ctx;
   ctx.withBuilder("builder");
   std::string result = std::string(tgfmt("", &ctx));
   EXPECT_TRUE(result.empty());
 }
 
 TEST(FormatTest, LiteralFmtStr) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("void foo {}", &ctx));
   EXPECT_THAT(result, StrEq("void foo {}"));
 }
 
-// Print single dollar literally
+/// Print single dollar literally.
 TEST(FormatTest, AdjacentDollar) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("$", &ctx));
   EXPECT_THAT(result, StrEq("$"));
 }
 
-// Print dangling dollar literally
+/// Print dangling dollar literally.
 TEST(FormatTest, DanglingDollar) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("foo bar baz$", &ctx));
   EXPECT_THAT(result, StrEq("foo bar baz$"));
 }
 
-// Allow escape dollars with '$$'
+/// Allow escape dollars with '$$'.
 TEST(FormatTest, EscapeDollars) {
   FmtContext ctx;
   std::string result =
       std::string(tgfmt("$$ $$$$ $$$0 $$$_self", &ctx.withSelf("self"), "-0"));
   EXPECT_THAT(result, StrEq("$ $$ $-0 $self"));
 }
 
 TEST(FormatTest, PositionalFmtStr) {
   FmtContext ctx;
   std::string b = "b";
   int c = 42;
   char d = 'd';
   std::string result =
       std::string(tgfmt("$0 $1 $2 $3", &ctx, "a", b, c + 1, d));
   EXPECT_THAT(result, StrEq("a b 43 d"));
 }
 
-// Output the placeholder if missing substitution
+/// Output the placeholder if missing substitution.
 TEST(FormatTest, PositionalFmtStrMissingParams) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("$0 %1 $2", &ctx));
   EXPECT_THAT(result, StrEq("$0<no-subst-found> %1 $2<no-subst-found>"));
 }
 
-// Allow flexible reference of positional parameters
+/// Allow flexible reference of positional parameters.
 TEST(FormatTest, PositionalFmtStrFlexibleRef) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("$2 $0 $2", &ctx, "a", "b", "c"));
   EXPECT_THAT(result, StrEq("c a c"));
 }
 
 TEST(FormatTest, PositionalFmtStrNoWhitespace) {
   FmtContext ctx;

 }
 
 TEST(FormatTest, PlaceHolderMissingSubst) {
   FmtContext ctx;
   std::string result = std::string(tgfmt("$_op", &ctx.withBuilder("builder")));
   EXPECT_THAT(result, StrEq("$_op<no-subst-found>"));
 }
 
-// Test commonly used delimiters in C++
+/// Test commonly used delimiters in C++.
 TEST(FormatTest, PlaceHolderFmtStrDelimiter) {
   FmtContext ctx;
   ctx.addSubst("m", "");
   std::string result = std::string(tgfmt("$m{$m($m[$m]$m)$m}$m|", &ctx));
   EXPECT_THAT(result, StrEq("{([])}|"));
 }
 
-// Test allowed characters in placeholder symbol
+/// Test allowed characters in placeholder symbol.
 TEST(FormatTest, CustomPlaceHolderFmtStrPlaceHolderChars) {
   FmtContext ctx;
   ctx.addSubst("m", "0 ");
   ctx.addSubst("m1", "1 ");
   ctx.addSubst("m2C", "2 ");
   ctx.addSubst("M_3", "3 ");
   std::string result = std::string(tgfmt("$m$m1$m2C$M_3", &ctx));
   EXPECT_THAT(result, StrEq("0 1 2 3 "));

mlir/unittests/TableGen/StructsGenTest.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gmock/gmock.h"
 #include <type_traits>
 
 namespace mlir {
 
-// Pull in generated enum utility declarations
+/// Pull in generated enum utility declarations and definitions.
 #include "StructAttrGenTest.h.inc"
-// And definitions
 #include "StructAttrGenTest.cpp.inc"
-// Helper that returns an example test::TestStruct for testing its
-// implementation.
+
+/// Helper that returns an example test::TestStruct for testing its
+/// implementation.
 static test::TestStruct getTestStruct(mlir::MLIRContext *context) {
   auto integerType = mlir::IntegerType::get(32, context);
   auto integerAttr = mlir::IntegerAttr::get(integerType, 127);
 
   auto floatType = mlir::FloatType::getF32(context);
   auto floatAttr = mlir::FloatAttr::get(floatType, 0.25);
 
   auto elementsType = mlir::RankedTensorType::get({2, 3}, integerType);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, {1, 2, 3, 4, 5, 6});
   auto optionalAttr = nullptr;
 
   return test::TestStruct::get(integerAttr, floatAttr, elementsAttr,
                                optionalAttr, context);
 }
 
-// Validates that test::TestStruct::classof correctly identifies a valid
-// test::TestStruct.
+/// Validates that test::TestStruct::classof correctly identifies a valid
+/// test::TestStruct.
 TEST(StructsGenTest, ClassofTrue) {
   mlir::MLIRContext context;
   auto structAttr = getTestStruct(&context);
   ASSERT_TRUE(test::TestStruct::classof(structAttr));
 }
 
-// Validates that test::TestStruct::classof fails when an extra attribute is in
-// the class.
+/// Validates that test::TestStruct::classof fails when an extra attribute is in
+/// the class.
 TEST(StructsGenTest, ClassofExtraFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Copy the set of named attributes.
   llvm::SmallVector<mlir::NamedAttribute, 5> newValues(expectedValues.begin(),
                                                        expectedValues.end());
 
   // Add an extra NamedAttribute.
   auto wrongId = mlir::Identifier::get("wrong", &context);
   auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].second);
   newValues.push_back(wrongAttr);
 
   // Make a new DictionaryAttr and validate.
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
-// Validates that test::TestStruct::classof fails when a NamedAttribute has an
-// incorrect name.
+/// Validates that test::TestStruct::classof fails when a NamedAttribute has an
+/// incorrect name.
 TEST(StructsGenTest, ClassofBadNameFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Create a copy of all but the first NamedAttributes.
   llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
       expectedValues.begin() + 1, expectedValues.end());
 
   // Add a copy of the first attribute with the wrong Identifier.
   auto wrongId = mlir::Identifier::get("wrong", &context);
   auto wrongAttr = mlir::NamedAttribute(wrongId, expectedValues[0].second);
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
-// Validates that test::TestStruct::classof fails when a NamedAttribute has an
-// incorrect type.
+/// Validates that test::TestStruct::classof fails when a NamedAttribute has an
+/// incorrect type.
 TEST(StructsGenTest, ClassofBadTypeFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Create a copy of all but the last NamedAttributes.
   llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
       expectedValues.begin(), expectedValues.end() - 1);
 
   // Add a copy of the last attribute with the wrong type.
   auto i64Type = mlir::IntegerType::get(64, &context);
   auto elementsType = mlir::RankedTensorType::get({3}, i64Type);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, ArrayRef<int64_t>{1, 2, 3});
   mlir::Identifier id = expectedValues.back().first;
   auto wrongAttr = mlir::NamedAttribute(id, elementsAttr);
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
-// Validates that test::TestStruct::classof fails when a NamedAttribute is
-// missing.
+/// Validates that test::TestStruct::classof fails when a NamedAttribute is
+/// missing.
 TEST(StructsGenTest, ClassofMissingFalse) {
   mlir::MLIRContext context;
   mlir::DictionaryAttr structAttr = getTestStruct(&context);
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Copy a subset of the structures Named Attributes.
   llvm::SmallVector<mlir::NamedAttribute, 3> newValues(
       expectedValues.begin() + 1, expectedValues.end());
 
   // Make a new DictionaryAttr and validate it is not a validate TestStruct.
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);
   ASSERT_FALSE(test::TestStruct::classof(badDictionary));
 }
 
-// Validate the accessor for the FloatAttr value.
+/// Validate the accessor for the FloatAttr value.
 TEST(StructsGenTest, GetFloat) {
   mlir::MLIRContext context;
   auto structAttr = getTestStruct(&context);
   auto returnedAttr = structAttr.sample_float();
   EXPECT_EQ(returnedAttr.getValueAsDouble(), 0.25);
 }
 
-// Validate the accessor for the IntegerAttr value.
+/// Validate the accessor for the IntegerAttr value.
 TEST(StructsGenTest, GetInteger) {
   mlir::MLIRContext context;
   auto structAttr = getTestStruct(&context);
   auto returnedAttr = structAttr.sample_integer();
   EXPECT_EQ(returnedAttr.getInt(), 127);
 }
 
-// Validate the accessor for the ElementsAttr value.
+/// Validate the accessor for the ElementsAttr value.
 TEST(StructsGenTest, GetElements) {
   mlir::MLIRContext context;
   auto structAttr = getTestStruct(&context);
   auto returnedAttr = structAttr.sample_elements();
   auto denseAttr = returnedAttr.dyn_cast<mlir::DenseElementsAttr>();
   ASSERT_TRUE(denseAttr);
 
   for (const auto &valIndexIt : llvm::enumerate(denseAttr.getIntValues())) {