[FileCheck][WIP] Added support for line anchors

[njames93]

Summary

Numerous test files using clang based diagnostics often include notes attached to them, potentially in completely different parts of the file.
If you want to ensure the note is displayed in the correct place you either have to specify the line number explicitly or as a relative offset from the line where the CHECK directive is.

The first approach always looks messy. The second, using @LINE+/-offset looks messier the larger the offset grows.
Aside from looking messy they also increase the risk of a failing test if something, potentially unrelated, is modified in the test file.

This patch tries to simplify this by allowing you to declare variable which expand to the line number they were defined on and can later be referred to in CHECK lines.

#define BAD_FUNCTION() badFunction() // LINE-ANCHOR: BAD_FUNC
// Further down in the file
  BAD_FUNCTION();
CHECK-NOTES: [[@LINE-1]]:3: warning: called a bad function
CHECK-NOTES :[[#BAD-FUNC]]:24: note: expanded from macro 'BAD_FUNCTION'

Relative offset are also supported using the same syntax for variables.
[[#NOTE-WORTHY+2]]

llvm/include/llvm/Support/FileCheck.h

 #include <vector>
 
 namespace llvm {
 
 /// Contains info about various FileCheck options.
 struct FileCheckRequest {
   std::vector<StringRef> CheckPrefixes;
   std::vector<StringRef> CommentPrefixes;
+  std::vector<StringRef> AnchorPrefixes;
   bool NoCanonicalizeWhiteSpace = false;
   std::vector<StringRef> ImplicitCheckNot;
   std::vector<StringRef> GlobalDefines;
   bool AllowEmptyInput = false;
   bool MatchFullLines = false;
   bool IgnoreCase = false;
   bool IsDefaultCheckPrefix = false;
   bool EnableVarScope = false;
enum FileCheckKind {
   CheckPlain,
   CheckNext,
   CheckSame,
   CheckNot,
   CheckDAG,
   CheckLabel,
   CheckEmpty,
   CheckComment,
+  CheckAnchor,
 
   /// Indicates the pattern only matches the end of file. This is used for
   /// trailing CHECK-NOTs.
   CheckEOF,
 
   /// Marks when parsing found a -NOT check combined with another CHECK suffix.
   CheckBadNot,
 

llvm/lib/Support/FileCheck.cpp

std::string Check::FileCheckType::getDescription(StringRef Prefix) const {
   case Check::CheckNot:
     return Prefix.str() + "-NOT";
   case Check::CheckDAG:
     return Prefix.str() + "-DAG";
   case Check::CheckLabel:
     return Prefix.str() + "-LABEL";
   case Check::CheckEmpty:
     return Prefix.str() + "-EMPTY";
+  case Check::CheckAnchor:
   case Check::CheckComment:
     return std::string(Prefix);
   case Check::CheckEOF:
     return "implicit EOF";
   case Check::CheckBadNot:
     return "bad NOT";
   case Check::CheckBadCount:
     return "bad COUNT";
   }
   llvm_unreachable("unknown FileCheckType");
 }
 
 static std::pair<Check::FileCheckType, StringRef>
 FindCheckType(const FileCheckRequest &Req, StringRef Buffer, StringRef Prefix) {
   if (Buffer.size() <= Prefix.size())
     return {Check::CheckNone, StringRef()};
 
   char NextChar = Buffer[Prefix.size()];
 
   StringRef Rest = Buffer.drop_front(Prefix.size() + 1);
 
   // Check for comment.
-  if (Req.CommentPrefixes.end() != std::find(Req.CommentPrefixes.begin(),
-                                             Req.CommentPrefixes.end(),
-                                             Prefix)) {
+  if (llvm::is_contained(Req.CommentPrefixes, Prefix)) {
     if (NextChar == ':')
       return {Check::CheckComment, Rest};
     // Ignore a comment prefix if it has a suffix like "-NOT".
     return {Check::CheckNone, StringRef()};
   }
 
+  // Check for line anchor
+  if (llvm::is_contained(Req.AnchorPrefixes, Prefix)) {
+    if (NextChar == ':')
+      return {Check::CheckAnchor, Rest};
+    return {Check::CheckNone, StringRef()};
+  }
+
   // Verify that the : is present after the prefix.
   if (NextChar == ':')
     return {Check::CheckPlain, Rest};
 
   if (NextChar != '-')
     return {Check::CheckNone, StringRef()};
 
   if (Rest.consume_front("COUNT-")) {

 void FileCheckPatternContext::createLineVariable() {
   assert(!LineVariable && "@LINE pseudo numeric variable already created");
   StringRef LineName = "@LINE";
   LineVariable = makeNumericVariable(
       LineName, ExpressionFormat(ExpressionFormat::Kind::Unsigned));
   GlobalNumericVariableTable[LineName] = LineVariable;
 }
 
+Error FileCheckPatternContext::createLineAnchorVariable(StringRef Buffer,
+                                                        SourceMgr &SM,
+                                                        unsigned LineNumber) {
+  if (Buffer[0] == '$')
+    return ErrorDiagnostic::get(SM, Buffer,
+                                "line anchor names can't start with '$'");
+  Expected<Pattern::VariableProperties> ParseVarResult =
+      Pattern::parseVariable(Buffer, SM);
+  if (!ParseVarResult)
+    return ParseVarResult.takeError();
+  if (ParseVarResult->IsPseudo) {
+    return ErrorDiagnostic::get(
+        SM, ParseVarResult->Name,
+        "line anchor names can't be pseudo variable names");
+  }
+  llvm::NumericVariable *&NumericVar =
+      GlobalNumericVariableTable[ParseVarResult->Name];
+  if (NumericVar)
+    return ErrorDiagnostic::get(SM, ParseVarResult->Name,
+                                "duplicate line anchor name '" +
+                                    ParseVarResult->Name + "'");
+  NumericVar = makeNumericVariable(
+      ParseVarResult->Name, ExpressionFormat(ExpressionFormat::Kind::Unsigned),
+      LineNumber);
+  NumericVar->setValue(ExpressionValue(LineNumber));
+  return Error::success();
+}
+
 FileCheck::FileCheck(FileCheckRequest Req)
     : Req(Req), PatternContext(std::make_unique<FileCheckPatternContext>()),
       CheckStrings(std::make_unique<std::vector<FileCheckString>>()) {}
 
 FileCheck::~FileCheck() = default;
 
 bool FileCheck::readCheckFile(
     SourceMgr &SM, StringRef Buffer, Regex &PrefixRE,
while (1) {
 
     // See if a prefix occurs in the memory buffer.
     StringRef UsedPrefix;
     StringRef AfterSuffix;
     std::tie(UsedPrefix, AfterSuffix) =
         FindFirstMatchingPrefix(Req, PrefixRE, Buffer, LineNumber, CheckTy);
     if (UsedPrefix.empty())
       break;
-    if (CheckTy != Check::CheckComment)
+    if (CheckTy != Check::CheckComment && CheckTy != Check::CheckAnchor)
       FoundUsedCheckPrefix = true;
 
     assert(UsedPrefix.data() == Buffer.data() &&
            "Failed to move Buffer's start forward, or pointed prefix outside "
            "of the buffer!");
     assert(AfterSuffix.data() >= Buffer.data() &&
            AfterSuffix.data() < Buffer.data() + Buffer.size() &&
            "Parsing after suffix doesn't start inside of buffer!");
while (1) {
     // Extract the pattern from the buffer.
     StringRef PatternBuffer = Buffer.substr(0, EOL);
     Buffer = Buffer.substr(EOL);
 
     // If this is a comment, we're done.
     if (CheckTy == Check::CheckComment)
       continue;
 
+    if (CheckTy == Check::CheckAnchor) {
+      if (Error E = PatternContext->createLineAnchorVariable(PatternBuffer, SM,
+                                                             LineNumber)) {
+        logAllUnhandledErrors(std::move(E), errs());
+        return true;
+      }
+      continue;
+    }
+
     // Parse the pattern.
     Pattern P(CheckTy, PatternContext.get(), LineNumber);
     if (P.parsePattern(PatternBuffer, UsedPrefix, SM, Req))
       return true;
 
     // Verify that CHECK-LABEL lines do not define or use variables
     if ((CheckTy == Check::CheckLabel) && P.hasVariable()) {
       SM.PrintMessage(
if (!UniquePrefixes.insert(Prefix).second) {
       return false;
     }
   }
   return true;
 }
 
 static const char *DefaultCheckPrefixes[] = {"CHECK"};
 static const char *DefaultCommentPrefixes[] = {"COM", "RUN"};
+static const char *DefaultAnchorPrefixes[] = {"LINE-ANCHOR"};
 
 bool FileCheck::ValidateCheckPrefixes() {
   StringSet<> UniquePrefixes;
   // Add default prefixes to catch user-supplied duplicates of them below.
   if (Req.CheckPrefixes.empty()) {
     for (const char *Prefix : DefaultCheckPrefixes)
       UniquePrefixes.insert(Prefix);
   }
   if (Req.CommentPrefixes.empty()) {
     for (const char *Prefix : DefaultCommentPrefixes)
       UniquePrefixes.insert(Prefix);
   }
+  if (Req.AnchorPrefixes.empty()) {
+    for (const char *Prefix : DefaultAnchorPrefixes)
+      UniquePrefixes.insert(Prefix);
+  }
   // Do not validate the default prefixes, or diagnostics about duplicates might
   // incorrectly indicate that they were supplied by the user.
   if (!ValidatePrefixes("check", UniquePrefixes, Req.CheckPrefixes))
     return false;
   if (!ValidatePrefixes("comment", UniquePrefixes, Req.CommentPrefixes))
     return false;
+  if (!ValidatePrefixes("anchor", UniquePrefixes, Req.AnchorPrefixes))
+    return false;
   return true;
 }
 
 Regex FileCheck::buildCheckPrefixRegex() {
   if (Req.CheckPrefixes.empty()) {
     for (const char *Prefix : DefaultCheckPrefixes)
       Req.CheckPrefixes.push_back(Prefix);
     Req.IsDefaultCheckPrefix = true;
   }
   if (Req.CommentPrefixes.empty()) {
     for (const char *Prefix : DefaultCommentPrefixes)
       Req.CommentPrefixes.push_back(Prefix);
   }
+  if (Req.AnchorPrefixes.empty()) {
+    for (const char *Prefix : DefaultAnchorPrefixes)
+      Req.AnchorPrefixes.push_back(Prefix);
+  }
 
   // We already validated the contents of CheckPrefixes and CommentPrefixes so
   // just concatenate them as alternatives.
   SmallString<32> PrefixRegexStr;
   for (size_t I = 0, E = Req.CheckPrefixes.size(); I != E; ++I) {
     if (I != 0)
       PrefixRegexStr.push_back('|');
     PrefixRegexStr.append(Req.CheckPrefixes[I]);
   }
   for (StringRef Prefix : Req.CommentPrefixes) {
     PrefixRegexStr.push_back('|');
     PrefixRegexStr.append(Prefix);
   }
+  for (StringRef Prefix : Req.AnchorPrefixes) {
+    PrefixRegexStr.push_back('|');
+    PrefixRegexStr.append(Prefix);
+  }
 
   return Regex(PrefixRegexStr);
 }
 
 Error FileCheckPatternContext::defineCmdlineVariables(
     ArrayRef<StringRef> CmdlineDefines, SourceMgr &SM) {
   assert(GlobalVariableTable.empty() && GlobalNumericVariableTable.empty() &&
          "Overriding defined variable with command-line variable definitions");

llvm/lib/Support/FileCheckImpl.h

public:
   /// \p SM for all definition parsing failures, if any, or Success otherwise.
   Error defineCmdlineVariables(ArrayRef<StringRef> CmdlineDefines,
                                SourceMgr &SM);
 
   /// Create @LINE pseudo variable. Value is set when pattern are being
   /// matched.
   void createLineVariable();
 
+  /// Creates a variable called \p Name with the value \p LineNumber.
+  /// Returns an Error if a numeric variable already exists with the same name.
+  Error createLineAnchorVariable(StringRef Buffer, SourceMgr &SM,
+                                 unsigned LineNumber);
+
   /// Undefines local variables (variables whose name does not start with a '$'
   /// sign), i.e. removes them from GlobalVariableTable and from
   /// GlobalNumericVariableTable and also clears the value of numeric
   /// variables.
   void clearLocalVars();
 
 private:
   /// Makes a new numeric variable and registers it for destruction when the

llvm/test/FileCheck/line-anchor-errors.txt

+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD1 -anchor-prefix BAD-ANCHOR1 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR1 %s
+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD2 -anchor-prefix BAD-ANCHOR2 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR2 %s
+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD3 -anchor-prefix BAD-ANCHOR3 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR3 %s
+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD4 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR4 %s
+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD5 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR5 %s
+; RUN: %ProtectFileCheckOutput not FileCheck -check-prefix BAD6 -anchor-prefix BAD-ANCHOR6 -input-file %s %s 2>&1 | FileCheck -check-prefix ERR6 %s
+
+BAD-ANCHOR1: @NAME
+ERR1: line-anchor-errors.txt:[[@LINE-1]]:14: error: line anchor names can't be pseudo variable names{{$}}
+
+BAD-ANCHOR2: $NAME
+ERR2: line-anchor-errors.txt:[[@LINE-1]]:14: error: line anchor names can't start with '$'{{$}}
+
+BAD-ANCHOR3: %NAME
+ERR3: line-anchor-errors.txt:[[@LINE-1]]:14: error: invalid variable name{{$}}
+
+LINE-ANCHOR: NAME
+BAD4: [[@NAME]]
+ERR4: line-anchor-errors.txt:[[@LINE-1]]:9: error: invalid pseudo numeric variable '@NAME'
+
+BAD5: [[NAME]]
+ERR5: line-anchor-errors.txt:1:1: note: uses undefined variable(s): "NAME"
+
+BAD-ANCHOR6: NAME
+BAD-ANCHOR6: NAME
+ERR6: line-anchor-errors.txt:[[@LINE-1]]:14: error: duplicate line anchor name 'NAME'

llvm/test/FileCheck/line-anchors.txt

+; RUN: FileCheck -input-file %s %s
+2
+; LINE-ANCHOR: ANCHOR
+4 aaa
+5 bbb
+6 ccc
+7 ddd
+8 eee
+9 fff
+10
+; LINE-ANCHOR: ANCHOR2
+12
+; CHECK: [[#ANCHOR+1]] aaa
+; CHECK-NEXT: [[#ANCHOR+2]] bbb
+; CHECK-NEXT: [[#ANCHOR+3]] ccc
+; CHECK-NEXT: [[#ANCHOR+4]] ddd
+; CHECK-NEXT: [[#ANCHOR2-3]] eee
+; CHECK-NEXT: [[#ANCHOR2-2]] fff
+; CHECK-NEXT: [[#ANCHOR2-1]] 
+20
+21 aaa ; LINE-ANCHOR: INPLACE
+; CHECK: [[#INPLACE]] aaa
+22

llvm/unittests/Support/FileCheckTest.cpp

#endif
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
   EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
 
+  expectDiagnosticError("line anchor names can't be pseudo variable names",
+                        Cxt.createLineAnchorVariable(
+                            bufferize(SM, "@LINE_NAME"), SM, ++LineNumber));
+  expectDiagnosticError("line anchor names can't start with '$'",
+                        Cxt.createLineAnchorVariable(
+                            bufferize(SM, "$LINE_NAME"), SM, ++LineNumber));
+  ASSERT_THAT_ERROR(
+      Cxt.createLineAnchorVariable(bufferize(SM, "LINE_NAME"), SM, 50),
+      Succeeded());
+  P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
+  ASSERT_FALSE(P.parsePattern("[[#LINE_NAME]]", "CHECK", SM, Req));
+  ASSERT_THAT_EXPECTED(P.match("50", MatchLen, SM), Succeeded());
+  P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
+  ASSERT_FALSE(
+      P.parsePattern(bufferize(SM, "[[#LINE_NAME+2]]"), "CHECK", SM, Req));
+  ASSERT_THAT_EXPECTED(P.match("52", MatchLen, SM), Succeeded());
+  P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
+  ASSERT_FALSE(
+      P.parsePattern(bufferize(SM, "[[#LINE_NAME-2]]"), "CHECK", SM, Req));
+  ASSERT_THAT_EXPECTED(P.match("48", MatchLen, SM), Succeeded());
+
   // Clear local variables and check global variables remain defined.
   Cxt.clearLocalVars();
   EXPECT_THAT_EXPECTED(Cxt.getPatternVarValue(GlobalVarStr), Succeeded());
   P = Pattern(Check::CheckPlain, &Cxt, ++LineNumber);
   ExpressionPointer = P.parseNumericSubstitutionBlock(
       GlobalNumVarRef, DefinedNumericVariable, /*IsLegacyLineExpr=*/false,
       LineNumber, &Cxt, SM);
   ASSERT_THAT_EXPECTED(ExpressionPointer, Succeeded());
   ExpressionVal = (*ExpressionPointer)->getAST()->eval();
   ASSERT_THAT_EXPECTED(ExpressionVal, Succeeded());
   EXPECT_EQ(cantFail(ExpressionVal->getSignedValue()), 36);
 }
 } // namespace

llvm/utils/FileCheck/FileCheck.cpp

 static cl::list<std::string> CommentPrefixes(
     "comment-prefixes", cl::CommaSeparated, cl::Hidden,
     cl::desc("Comma-separated list of comment prefixes to use from check file\n"
              "(defaults to 'COM,RUN'). Please avoid using this feature in\n"
              "LLVM's LIT-based test suites, which should be easier to\n"
              "maintain if they all follow a consistent comment style. This\n"
              "feature is meant for non-LIT test suites using FileCheck."));
 
+static cl::list<std::string>
+    AnchorPrefixes("anchor-prefix", cl::CommaSeparated, cl::Hidden,
+                   cl::desc("prefix to use for line anchors\n"
+                            "(defaults to 'LINE-ANCHOR')."));
+
 static cl::opt<bool> NoCanonicalizeWhiteSpace(
     "strict-whitespace",
     cl::desc("Do not treat all horizontal whitespace as equivalent"));
 
 static cl::opt<bool> IgnoreCase(
     "ignore-case",
     cl::desc("Use case-insensitive matching"));
 
std::string GetCheckTypeAbbreviation(Check::FileCheckType Ty) {
   case Check::CheckDAG:
     return "dag";
   case Check::CheckLabel:
     return "label";
   case Check::CheckEmpty:
     return "empty";
   case Check::CheckComment:
     return "com";
+  case Check::CheckAnchor:
+    return "anchor";
   case Check::CheckEOF:
     return "eof";
   case Check::CheckBadNot:
     return "bad-not";
   case Check::CheckBadCount:
     return "bad-count";
   case Check::CheckNone:
     llvm_unreachable("invalid FileCheckType");
int main(int argc, char **argv) {
 
   FileCheckRequest Req;
   for (StringRef Prefix : CheckPrefixes)
     Req.CheckPrefixes.push_back(Prefix);
 
   for (StringRef Prefix : CommentPrefixes)
     Req.CommentPrefixes.push_back(Prefix);
 
+  for (StringRef Prefix : AnchorPrefixes)
+    Req.AnchorPrefixes.push_back(Prefix);
+
   for (StringRef CheckNot : ImplicitCheckNot)
     Req.ImplicitCheckNot.push_back(CheckNot);
 
   bool GlobalDefineError = false;
   for (StringRef G : GlobalDefines) {
     size_t EqIdx = G.find('=');
     if (EqIdx == std::string::npos) {
       errs() << "Missing equal sign in command-line definition '-D" << G