Allow checking for asm diags with a specific column number

[olista01]

Summary

This adds extra syntax to the comments parsed by llvm-mc -verify-asm-diags to allow chekcing that a diagnostic is emitted at a specific column number.

test/MC/ARM/verify-diagnostics-all-matching.s

// RUN: llvm-mc -triple armv7a--none-eabi < %s -verify-asm-diags 2>&1 | FileCheck %s
   // expected-error@+1 {{invalid instruction}}
   wibble
 
   foo; bar // expected-error {{invalid instruction}} expected-error {{invalid instruction}}
 
   foo; bar // expected-error    {{invalid instruction}}
            // expected-error@-1 {{invalid instruction}}
 
+  foo; bar // expected-error:3 {{invalid instruction}} expected-error:8 {{invalid instruction}}
+
 // CHECK-NOT: error

test/MC/ARM/verify-diagnostics-column-number.s

+// RUN: not llvm-mc -triple armv7a--none-eabi < %s -verify-asm-diags 2>&1 | FileCheck %s
+
+  foo // expected-error:3 {{invalid instruction}}
+// CHECK-NOT: error
+
+  foo // expected-error:4 {{invalid instruction}}
+// CHECK-DAG: :[[@LINE-1]]:3: error: 'error' seen but not expected: invalid instruction
+// CHECK-DAG: :[[@LINE-2]]:10: error: 'error' expected but not seen: invalid instruction

test/MC/ARM/verify-diagnostics-comment-parsing.s

 // RUN: not llvm-mc -triple armv7a--none-eabi < %s -verify-asm-diags 2>&1 | FileCheck %s
 
 // expected-foo {{text}}
 // CHECK: :[[@LINE-1]]:13: error: unsupported diagnostic severity
 
 // expected-warning {{text}}
 // CHECK-NOT: :[[@LINE-1]]:{{.*}}: error: unsupported diagnostic severity
 
 // expected-note {{text}}
 // CHECK-NOT: :[[@LINE-1]]:{{.*}}: error: unsupported diagnostic severity
 
 // expected-error
 // CHECK: :[[@LINE-1]]:18: error: cannot find start ('{{[{][{]}}') of expected string
 
 // expected-error {{
 // CHECK: :[[@LINE-1]]:21: error: cannot find end ('}}') of expected string
+
+// expected-error@a {{message}}
+// CHECK: :[[@LINE-1]]:19: error: expected integer line number or offset
+
+// expected-error:a {{message}}
+// CHECK: :[[@LINE-1]]:19: error: expected integer column number
+
+// expected-error@+4:a {{message}}
+// CHECK: :[[@LINE-1]]:22: error: expected integer column number

tools/llvm-mc/llvm-mc.cpp

 class VerifyAsmDiagnosticConsumer : public AsmCommentConsumer {
   // Information stored about a diagnostic, either expected (from a parsed
   // comment) or seen (from an actually emitted diag).
   struct PendingDiag {
     std::string DiagText;
     SourceMgr::DiagKind Kind;
     // The line number on which the diagnostic was seen or is expected.
     int LineNo;
+    // The column number at which the diagnostic was seen or is expected, or 0
+    // for a diagnostic expected at any point on the line.
+    int ColumnNo;
     // The exact location at which the diagnostic was reported, or the expected
     // diagnostic was described. This is just used for emitting our own
     // diagnostics, as we wouldn't expect the expected and actual locations to
     // match up exactly.
     SMLoc Loc;
     // True if this is an expected diagnostic, and we have already seen an
     // actual diagnostic that matches it.
     bool Matched;
 
     // Constructor for an actually emitted diagnostic.
     PendingDiag(const SMDiagnostic &Diag)
         : DiagText(Diag.getMessage()), Kind(Diag.getKind()),
-          LineNo(Diag.getLineNo()), Loc(Diag.getLoc()), Matched(false) {}
+          LineNo(Diag.getLineNo()), ColumnNo(Diag.getColumnNo()+1),
+          Loc(Diag.getLoc()), Matched(false) {}
 
     // Constructor for an expected diagnostic.
-    PendingDiag(unsigned LineNo, StringRef ExpectedText,
+    PendingDiag(unsigned LineNo, unsigned ColumnNo, StringRef ExpectedText,
                 SourceMgr::DiagKind Kind, SMLoc Loc)
-        : DiagText(ExpectedText), Kind(Kind), LineNo(LineNo), Loc(Loc),
-          Matched(false) {}
+        : DiagText(ExpectedText), Kind(Kind), LineNo(LineNo),
+          ColumnNo(ColumnNo), Loc(Loc), Matched(false) {}
 
     bool operator<(const PendingDiag &RHS) const { return LineNo < RHS.LineNo; }
+
+    // Returns true if this expected diagnostic matches SeenDiag, and has not
+    // previously been matched agains a diagnostic.
+    bool Matches(const PendingDiag &SeenDiag) const {
+      if (Matched)
+        return false;
+      if (SeenDiag.DiagText.find(DiagText) == std::string::npos)
+        return false;
+      if (Kind != SeenDiag.Kind)
+        return false;
+      if (ColumnNo != 0 && ColumnNo != SeenDiag.ColumnNo)
+        return false;
+      return true;
+    }
   };
 
   SourceMgr &SrcMgr;
   MCAsmParser &Parser;
   // True if we have emitted an error ourselves (for an unparsable comment, or
   // a mismatch between expected or seen diagnostics).
   bool HadError;
 
while (!PH.Done()) {
         if (RelativeDir == 0)
           LineNo = ExplicitLineNo;
         else
           LineNo = LineNo + ((int)ExplicitLineNo * RelativeDir);
       }
 
       PH.SkipWhitespace();
 
+      // Parse optional column number
+      unsigned ColumnNo = 0;
+      if (PH.Next(":")) {
+        PH.Advance();
+        if (!PH.Next(ColumnNo)) {
+          ReportError(getCurrentLoc(Loc, PH),
+                      "expected integer column number");
+          continue;
+        }
+        PH.Advance();
+      }
+
+      PH.SkipWhitespace();
+
       // Parse the expected diagnostic text.
       if (!PH.Next("{{")) {
         ReportError(getCurrentLoc(Loc, PH),
                     "cannot find start ('{{') of expected string");
         continue;
       }
       PH.Advance();
       const char *const ContentBegin = PH.C; // mark content begin
 
       // Search for token: }}
       if (!PH.SearchClosingBrace("{{", "}}")) {
         ReportError(getCurrentLoc(Loc, PH),
                     "cannot find end ('}}') of expected string");
         continue;
       }
       const char *const ContentEnd = PH.P; // mark content end
       PH.Advance();
 
       ExpectedDiags.push_back(PendingDiag(
-          LineNo, StringRef(ContentBegin, ContentEnd - ContentBegin), Kind,
-          DirectiveLoc));
+          LineNo, ColumnNo, StringRef(ContentBegin, ContentEnd - ContentBegin),
+          Kind, DirectiveLoc));
     }
   }
 
   // The actual diagnostic callback called by the SourceMgr, this just converts
   // the function ptr + context ptr into a member function call.
   static void HandleDiagnosticCallback(const SMDiagnostic &Diag, void *Context) {
     ((VerifyAsmDiagnosticConsumer*)Context)->HandleDiagnostic(Diag);
   }
while (SeenIt != SeenEnd || ExpectedIt != ExpectedEnd) {
           [LineNo](PendingDiag &D) { return D.LineNo == LineNo; });
       auto ExpectedNextLine = std::partition(
           ExpectedIt, ExpectedEnd,
           [LineNo](PendingDiag &D) { return D.LineNo == LineNo; });
 
       // Iterate over seen diags, checking for a matching expected diag.
       for (; SeenIt != SeenNextLine; ++SeenIt) {
         auto ExpectedMatch = std::find_if(ExpectedIt, ExpectedNextLine,
-                                          [SeenIt](PendingDiag &Expected) {
-          return SeenIt->DiagText.find(Expected.DiagText) !=
-                     std::string::npos &&
-                 SeenIt->Kind == Expected.Kind && !Expected.Matched;
+                                          [SeenIt](const PendingDiag &Expected) {
+          return Expected.Matches(*SeenIt);
         });
         if (ExpectedMatch != ExpectedNextLine) {
           ExpectedMatch->Matched = true;
         } else {
           ReportMismatchError(*SeenIt, true);
         }
       }