[TableGen] Track reference locations of Records/RecordVals

[rriddle]

Summary

This is extremely useful for language tooling as it allows
for providing go-to-def/find-references/etc. for many
more situations than what is currently possible.

[rriddle]

Here is an example screenshot of finding uses of a field in vscode using the TableGen language server:

[lattner]

Very cool, it'd be great to improve this in tblgen!

I'm a long way from working on this code, but the representation is a bit odd. Typically you'd put a location on VarInit when forming the VarInit::get. Having a location on this would enable far better diagnostics across all of tblgen.

That said, it would make the jump to definition implementation slightly more awkward, because it has to scan the AST to find references, instead of having them on the declaration. I'm concerned that taking a step like in this patch would be a sideways step for improving tblgen though.

[rriddle]

In D134087#3797798, @lattner wrote:

Very cool, it'd be great to improve this in tblgen!

I'm a long way from working on this code, but the representation is a bit odd. Typically you'd put a location on VarInit when forming the VarInit::get. Having a location on this would enable far better diagnostics across all of tblgen.

That said, it would make the jump to definition implementation slightly more awkward, because it has to scan the AST to find references, instead of having them on the declaration. I'm concerned that taking a step like in this patch would be a sideways step for improving tblgen though.

The problem that I ran into was that a lot of stuff kind of requires that the Inits get folded and are uniqued, which would no longer be the case if we put locations on them. From there this patch arose, because I didn't want to broach the "rewrite the world" just to get better locations.

[rriddle]

In D134087#3797799, @rriddle wrote:

In D134087#3797798, @lattner wrote:

Very cool, it'd be great to improve this in tblgen!

I'm a long way from working on this code, but the representation is a bit odd. Typically you'd put a location on VarInit when forming the VarInit::get. Having a location on this would enable far better diagnostics across all of tblgen.

That said, it would make the jump to definition implementation slightly more awkward, because it has to scan the AST to find references, instead of having them on the declaration. I'm concerned that taking a step like in this patch would be a sideways step for improving tblgen though.

The problem that I ran into was that a lot of stuff kind of requires that the Inits get folded and are uniqued, which would no longer be the case if we put locations on them. From there this patch arose, because I didn't want to broach the "rewrite the world" just to get better locations.

I suppose framed in another way, I view this patch as a pragmatic step to enabling better tooling without fundamentally restructuring how tablegen works internally. I would love to just rewrite TableGen to actually work like a real programming language, but the cost of that is quite high. I also
don't think this patch is that high of a maintenance burden even if we want to do things in a better way eventually.

[lattner]

The problem that I ran into was that a lot of stuff kind of requires that the Inits get folded and are uniqued, which would no longer be the case if we put locations on them. From there this patch arose, because I didn't want to broach the "rewrite the world" just to get better locations.

Aha, I didn't remember that, yes I agree that you cannot unique things if they carry locations. If that is inherent to how tblgen works, then ok.

[jpienaar]

In D134087#3804630, @lattner wrote:

The problem that I ran into was that a lot of stuff kind of requires that the Inits get folded and are uniqued, which would no longer be the case if we put locations on them. From there this patch arose, because I didn't want to broach the "rewrite the world" just to get better locations.

Aha, I didn't remember that, yes I agree that you cannot unique things if they carry locations. If that is inherent to how tblgen works, then ok.

Would it be possible to do something like unique/have equivalence set representative have union of all locations and unique excluding location?

I haven't looked at innards to see if the above possible, this change doesn't seem too invasive and the results are very useful to produce better error messages too. This is already an improvement in location tracking looking at the changed test results, so LG from me.

llvm/lib/TableGen/TGParser.cpp

2538

Why only if singleton?

llvm/lib/TableGen/TGParser.h

203

What does OverrideDefLoc mean?

llvm/include/llvm/TableGen/Record.h

 
 private:
   Init *Name;
   SMLoc Loc; // Source location of definition of name.
   PointerIntPair<RecTy *, 2, FieldKind> TyAndKind;
   Init *Value;
   bool IsUsed = false;
 
+  /// Reference locations to this record value.
+  SmallVector<SMRange> ReferenceLocs;
+
 public:
   RecordVal(Init *N, RecTy *T, FieldKind K);
   RecordVal(Init *N, SMLoc Loc, RecTy *T, FieldKind K);
 
   /// Get the record keeper used to unique this value.
   RecordKeeper &getRecordKeeper() const { return Name->getRecordKeeper(); }
 
   /// Get the name of the field as a StringRef.
public:
   Init *getValue() const { return Value; }
 
   /// Set the value of the field from an Init.
   bool setValue(Init *V);
 
   /// Set the value and source location of the field.
   bool setValue(Init *V, SMLoc NewLoc);
 
+  /// Add a reference to this record value.
+  void addReferenceLoc(SMRange Loc) { ReferenceLocs.push_back(Loc); }
+
+  /// Return the references of this record value.
+  ArrayRef<SMRange> getReferenceLocs() const { return ReferenceLocs; }
+
   /// Whether this value is used. Useful for reporting warnings, for example
   /// when a template argument is unused.
   void setUsed(bool Used) { IsUsed = Used; }
   bool isUsed() const { return IsUsed; }
 
   void dump() const;
 
   /// Print the value to an output stream, possibly with a semicolon.
struct AssertionInfo {
     // removed in C++20 when braced initialization is supported.
     AssertionInfo(SMLoc Loc, Init *Condition, Init *Message)
         : Loc(Loc), Condition(Condition), Message(Message) {}
   };
 
 private:
   Init *Name;
   // Location where record was instantiated, followed by the location of
-  // multiclass prototypes used.
+  // multiclass prototypes used, and finally by the locations of references to
+  // this record.
   SmallVector<SMLoc, 4> Locs;
   SmallVector<SMLoc, 0> ForwardDeclarationLocs;
+  SmallVector<SMRange, 0> ReferenceLocs;
   SmallVector<Init *, 0> TemplateArgs;
   SmallVector<RecordVal, 0> Values;
   SmallVector<AssertionInfo, 0> Assertions;
 
   // All superclasses in the inheritance forest in post-order (yes, it
   // must be a forest; diamond-shaped inheritance is not allowed).
   SmallVector<std::pair<Record *, SMRange>, 0> SuperClasses;
 
public:
 
   ArrayRef<SMLoc> getLoc() const { return Locs; }
   void appendLoc(SMLoc Loc) { Locs.push_back(Loc); }
 
   ArrayRef<SMLoc> getForwardDeclarationLocs() const {
     return ForwardDeclarationLocs;
   }
 
+  /// Add a reference to this record value.
+  void appendReferenceLoc(SMRange Loc) { ReferenceLocs.push_back(Loc); }
+
+  /// Return the references of this record value.
+  ArrayRef<SMRange> getReferenceLocs() const { return ReferenceLocs; }
+
   // Update a class location when encountering a (re-)definition.
   void updateClassLoc(SMLoc Loc);
 
   // Make the type that this record should have based on its superclasses.
   RecordRecTy *getType();
 
   /// get the corresponding DefInit.
   DefInit *getDefInit();

llvm/lib/TableGen/TGLexer.h

public:
   }
   std::pair<int64_t, unsigned> getCurBinaryIntVal() const {
     assert(CurCode == tgtok::BinaryIntVal &&
            "This token isn't a binary integer");
     return std::make_pair(CurIntVal, (CurPtr - TokStart)-2);
   }
 
   SMLoc getLoc() const;
+  SMRange getLocRange() const;
 
 private:
   /// LexToken - Read the next token and return its code.
   tgtok::TokKind LexToken(bool FileOrLineStart = false);
 
   tgtok::TokKind ReturnError(SMLoc Loc, const Twine &Msg);
   tgtok::TokKind ReturnError(const char *Loc, const Twine &Msg);
 

llvm/lib/TableGen/TGLexer.cpp

TGLexer::TGLexer(SourceMgr &SM, ArrayRef<std::string> Macros) : SrcMgr(SM) {
   for (const std::string &MacroName : Macros)
     DefinedMacros.insert(MacroName);
 }
 
 SMLoc TGLexer::getLoc() const {
   return SMLoc::getFromPointer(TokStart);
 }
 
+SMRange TGLexer::getLocRange() const {
+  return {getLoc(), SMLoc::getFromPointer(CurPtr)};
+}
+
 /// ReturnError - Set the error to the specified string at the specified
 /// location.  This is defined to always return tgtok::Error.
 tgtok::TokKind TGLexer::ReturnError(SMLoc Loc, const Twine &Msg) {
   PrintError(Loc, Msg);
   return tgtok::Error;
 }
 
 tgtok::TokKind TGLexer::ReturnError(const char *Loc, const Twine &Msg) {

llvm/lib/TableGen/TGParser.h

assert(ExpectedStackTop == CurLocalScope.get() &&
            "Mismatched pushes and pops of local variable scopes");
     CurLocalScope = CurLocalScope->extractParent();
   }
 
 private: // Semantic analysis methods.
   bool AddValue(Record *TheRec, SMLoc Loc, const RecordVal &RV);
   bool SetValue(Record *TheRec, SMLoc Loc, Init *ValName,
                 ArrayRef<unsigned> BitList, Init *V,
-                bool AllowSelfAssignment = false);
+                bool AllowSelfAssignment = false, bool OverrideDefLoc = true);
   bool AddSubClass(Record *Rec, SubClassReference &SubClass);
   bool AddSubClass(RecordsEntry &Entry, SubClassReference &SubClass);
   bool AddSubMultiClass(MultiClass *CurMC,
                         SubMultiClassReference &SubMultiClass);
 
   using SubstStack = SmallVector<std::pair<Init *, Init *>, 8>;
 
   bool addEntry(RecordsEntry E);
private:  // Parser methods.
 
   bool ParseTemplateArgList(Record *CurRec);
   Init *ParseDeclaration(Record *CurRec, bool ParsingTemplateArgs);
   VarInit *ParseForeachDeclaration(Init *&ForeachListValue);
 
   SubClassReference ParseSubClassReference(Record *CurRec, bool isDefm);
   SubMultiClassReference ParseSubMultiClassReference(MultiClass *CurMC);
 
-  Init *ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
+  Init *ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
                      IDParseMode Mode = ParseValueMode);
   Init *ParseSimpleValue(Record *CurRec, RecTy *ItemType = nullptr,
                          IDParseMode Mode = ParseValueMode);
   Init *ParseValue(Record *CurRec, RecTy *ItemType = nullptr,
                    IDParseMode Mode = ParseValueMode);
   void ParseValueList(SmallVectorImpl<llvm::Init*> &Result,
                       Record *CurRec, RecTy *ItemType = nullptr);
   bool ParseTemplateArgValueList(SmallVectorImpl<llvm::Init *> &Result,

llvm/lib/TableGen/TGParser.cpp

bool TGParser::AddValue(Record *CurRec, SMLoc Loc, const RecordVal &RV) {
   }
   return false;
 }
 
 /// SetValue -
 /// Return true on error, false on success.
 bool TGParser::SetValue(Record *CurRec, SMLoc Loc, Init *ValName,
                         ArrayRef<unsigned> BitList, Init *V,
-                        bool AllowSelfAssignment) {
+                        bool AllowSelfAssignment, bool OverrideDefLoc) {
   if (!V) return false;
 
   if (!CurRec) CurRec = &CurMultiClass->Rec;
 
   RecordVal *RV = CurRec->getValue(ValName);
   if (!RV)
     return Error(Loc, "Value '" + ValName->getAsUnquotedString() +
                  "' unknown!");
if (!BitList.empty()) {
 
     for (unsigned i = 0, e = CurVal->getNumBits(); i != e; ++i)
       if (!NewBits[i])
         NewBits[i] = CurVal->getBit(i);
 
     V = BitsInit::get(Records, NewBits);
   }
 
-  if (RV->setValue(V, Loc)) {
+  if (OverrideDefLoc ? RV->setValue(V, Loc) : RV->setValue(V)) {
     std::string InitType;
     if (BitsInit *BI = dyn_cast<BitsInit>(V))
       InitType = (Twine("' of type bit initializer with length ") +
                   Twine(BI->getNumBits())).str();
     else if (TypedInit *TI = dyn_cast<TypedInit>(V))
       InitType = (Twine("' of type '") + TI->getType()->getAsString()).str();
     return Error(Loc, "Field '" + ValName->getAsUnquotedString() +
                           "' of type '" + RV->getType()->getAsString() +
Record *TGParser::ParseClassID() {
   Record *Result = Records.getClass(Lex.getCurStrVal());
   if (!Result) {
     std::string Msg("Couldn't find class '" + Lex.getCurStrVal() + "'");
     if (MultiClasses[Lex.getCurStrVal()].get())
       TokError(Msg + ". Use 'defm' if you meant to use multiclass '" +
                Lex.getCurStrVal() + "'");
     else
       TokError(Msg);
+  } else {
+    Result->appendReferenceLoc(Lex.getLocRange());
   }
 
   Lex.Lex();
   return Result;
 }
 
 /// ParseMultiClassID - Parse and resolve a reference to a multiclass name.
 /// This returns null on error.
if (!consume(tgtok::greater)) {
       return nullptr;
     }
     return ListRecTy::get(SubType);
   }
   }
 }
 
 /// ParseIDValue
-Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMLoc NameLoc,
+Init *TGParser::ParseIDValue(Record *CurRec, StringInit *Name, SMRange NameLoc,
                              IDParseMode Mode) {
   if (CurRec) {
-    if (const RecordVal *RV = CurRec->getValue(Name))
+    if (RecordVal *RV = CurRec->getValue(Name)) {
+      RV->addReferenceLoc(NameLoc);
       return VarInit::get(Name, RV->getType());
     }
+  }
 
   if ((CurRec && CurRec->isClass()) || CurMultiClass) {
     Init *TemplateArgName;
     if (CurMultiClass) {
       TemplateArgName =
           QualifyName(CurMultiClass->Rec, CurMultiClass, Name, "::");
     } else
       TemplateArgName = QualifyName(*CurRec, CurMultiClass, Name, ":");
 
     Record *TemplateRec = CurMultiClass ? &CurMultiClass->Rec : CurRec;
     if (TemplateRec->isTemplateArg(TemplateArgName)) {
       RecordVal *RV = TemplateRec->getValue(TemplateArgName);
       assert(RV && "Template arg doesn't exist??");
       RV->setUsed(true);
+      RV->addReferenceLoc(NameLoc);
       return VarInit::get(TemplateArgName, RV->getType());
     } else if (Name->getValue() == "NAME") {
       return VarInit::get(TemplateArgName, StringRecTy::get(Records));
     }
   }
 
   if (CurLocalScope)
     if (Init *I = CurLocalScope->getVar(Name->getValue()))
       return I;
 
   // If this is in a foreach loop, make sure it's not a loop iterator
   for (const auto &L : Loops) {
     if (L->IterVar) {
       VarInit *IterVar = dyn_cast<VarInit>(L->IterVar);
       if (IterVar && IterVar->getNameInit() == Name)
         return IterVar;
     }
   }
 
   if (Mode == ParseNameMode)
     return Name;
 
-  if (Init *I = Records.getGlobal(Name->getValue()))
+  if (Init *I = Records.getGlobal(Name->getValue())) {
+    // Add a reference to the global if it's a record.
+    if (auto *Def = dyn_cast<DefInit>(I))
+      Def->getDef()->appendReferenceLoc(NameLoc);
     return I;
+  }
 
   // Allow self-references of concrete defs, but delay the lookup so that we
   // get the correct type.
   if (CurRec && !CurRec->isClass() && !CurMultiClass &&
       CurRec->getNameInit() == Name)
     return UnOpInit::get(UnOpInit::CAST, Name, CurRec->getType());
 
-  Error(NameLoc, "Variable not defined: '" + Name->getValue() + "'");
+  Error(NameLoc.Start, "Variable not defined: '" + Name->getValue() + "'");
   return nullptr;
 }
 
 /// ParseOperation - Parse an operator.  This returns null on error.
 ///
 /// Operation ::= XOperator ['<' Type '>'] '(' Args ')'
 ///
 Init *TGParser::ParseOperation(Record *CurRec, RecTy *ItemType) {
case tgtok::CodeFragment:
     R = StringInit::get(Records, Lex.getCurStrVal(), StringInit::SF_Code);
     Lex.Lex();
     break;
   case tgtok::question:
     R = UnsetInit::get(Records);
     Lex.Lex();
     break;
   case tgtok::Id: {
-    SMLoc NameLoc = Lex.getLoc();
+    SMRange NameLoc = Lex.getLocRange();
     StringInit *Name = StringInit::get(Records, Lex.getCurStrVal());
     if (Lex.Lex() != tgtok::less)  // consume the Id.
       return ParseIDValue(CurRec, Name, NameLoc, Mode);    // Value ::= IDValue
 
     // Value ::= CLASSID '<' ValueListNE '>' (CLASSID has been consumed)
     // This is supposed to synthesize a new anonymous definition, deriving
     // from the class with the template arguments, but no body.
     Record *Class = Records.getClass(Name->getValue());
     if (!Class) {
-      Error(NameLoc, "Expected a class name, got '" + Name->getValue() + "'");
+      Error(NameLoc.Start,
+            "Expected a class name, got '" + Name->getValue() + "'");
       return nullptr;
     }
 
     SmallVector<Init *, 8> Args;
     Lex.Lex(); // consume the <
     if (ParseTemplateArgValueList(Args, CurRec, Class))
       return nullptr; // Error parsing value list.
 
-    if (CheckTemplateArgValues(Args, NameLoc, Class))
+    if (CheckTemplateArgValues(Args, NameLoc.Start, Class))
       return nullptr; // Error checking template argument values.
 
     // Loop through the arguments that were not specified and make sure
     // they have a complete value.
     ArrayRef<Init *> TArgs = Class->getTemplateArgs();
     for (unsigned I = Args.size(), E = TArgs.size(); I < E; ++I) {
       RecordVal *Arg = Class->getValue(TArgs[I]);
-      if (!Arg->getValue()->isComplete()) 
-        Error(NameLoc, "Value not specified for template argument '" +
-                           TArgs[I]->getAsUnquotedString() + "' (#" + Twine(I) +
-                           ") of parent class '" +
+      if (!Arg->getValue()->isComplete()) {
+        Error(NameLoc.Start, "Value not specified for template argument '" +
+                                 TArgs[I]->getAsUnquotedString() + "' (#" +
+                                 Twine(I) + ") of parent class '" +
                                  Class->getNameInitAsString() + "'");
-              
+      }
     }
 
+    Class->appendReferenceLoc(NameLoc);
     return VarDefInit::get(Class, Args)->Fold();
   }
   case tgtok::l_brace: {           // Value ::= '{' ValueList '}'
     SMLoc BraceLoc = Lex.getLoc();
     Lex.Lex(); // eat the '{'
     SmallVector<Init*, 16> Vals;
 
     if (Lex.getCode() != tgtok::r_brace) {
case tgtok::l_square: {
       }
       break;
     }
     case tgtok::dot: {
       if (Lex.Lex() != tgtok::Id) { // eat the .
         TokError("expected field identifier after '.'");
         return nullptr;
       }
+      SMRange FieldNameLoc = Lex.getLocRange();
       StringInit *FieldName = StringInit::get(Records, Lex.getCurStrVal());
       if (!Result->getFieldType(FieldName)) {
         TokError("Cannot access field '" + Lex.getCurStrVal() + "' of value '" +
                  Result->getAsString() + "'");
         return nullptr;
       }
+
+      // Add a reference to this field if we know the record class.
+      if (auto *TI = dyn_cast<TypedInit>(Result)) {
+        if (auto *RecTy = dyn_cast<RecordRecTy>(TI->getType())) {
+          auto RecClasses = RecTy->getClasses();
+          if (RecClasses.size() == 1) {
+            if (auto *RV = RecClasses[0]->getValue(FieldName))
+              RV->addReferenceLoc(FieldNameLoc);
+          }
+        }
+      }
+
       Result = FieldInit::get(Result, FieldName)->Fold(CurRec);
       Lex.Lex();  // eat field name
       break;
     }
 
     case tgtok::paste:
       SMLoc PasteLoc = Lex.getLoc();
       TypedInit *LHS = dyn_cast<TypedInit>(Result);
Init *TGParser::ParseDeclaration(Record *CurRec,
   if (BadField)
     return nullptr;
 
   // If a value is present, parse it and set new field's value.
   if (consume(tgtok::equal)) {
     SMLoc ValLoc = Lex.getLoc();
     Init *Val = ParseValue(CurRec, Type);
     if (!Val ||
-        SetValue(CurRec, ValLoc, DeclName, None, Val))
+        SetValue(CurRec, ValLoc, DeclName, None, Val,
+                 /*AllowSelfAssignment=*/false, /*OverrideDefLoc=*/false)) {
       // Return the name, even if an error is thrown.  This is so that we can
       // continue to make some progress, even without the value having been
       // initialized.
       return DeclName;
     }
+  }
 
   return DeclName;
 }
 
 /// ParseForeachDeclaration - Read a foreach declaration, returning
 /// the name of the declared object or a NULL Init on error.  Return
 /// the name of the parsed initializer list through ForeachListName.
 ///

 ///
 ///   DefInst ::= DEF ObjectName ObjectBody
 ///
 bool TGParser::ParseDef(MultiClass *CurMultiClass) {
   SMLoc DefLoc = Lex.getLoc();
   assert(Lex.getCode() == tgtok::Def && "Unknown tok");
   Lex.Lex();  // Eat the 'def' token.
 
+  // If the name of the def is an Id token, use that for the location.
+  // Otherwise, the name is more complex and we use the location of the 'def'
+  // token.
+  SMLoc NameLoc = Lex.getCode() == tgtok::Id ? Lex.getLoc() : DefLoc;
+
   // Parse ObjectName and make a record for it.
   std::unique_ptr<Record> CurRec;
   Init *Name = ParseObjectName(CurMultiClass);
   if (!Name)
     return true;
 
-  if (isa<UnsetInit>(Name))
-    CurRec = std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
+  if (isa<UnsetInit>(Name)) {
+    CurRec =
+        std::make_unique<Record>(Records.getNewAnonymousName(), DefLoc, Records,
                                  /*Anonymous=*/true);
-  else
-    CurRec = std::make_unique<Record>(Name, DefLoc, Records);
+  } else {
+    CurRec = std::make_unique<Record>(Name, NameLoc, Records);
+  }
 
   if (ParseObjectBody(CurRec.get()))
     return true;
 
   return addEntry(std::move(CurRec));
 }
 
 /// ParseDefset - Parse a defset statement.

llvm/test/TableGen/ConstraintChecking1.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Unrecognized constraint '$dest1 ~ $src2' in 'Foo'
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Unrecognized constraint '$dest1 ~ $src2' in 'Foo'
 def Foo : TestInstructionWithConstraints<"$dest1 ~ $src2">;

llvm/test/TableGen/ConstraintChecking2.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Illegal format for @earlyclobber constraint in 'Foo'
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Illegal format for @earlyclobber constraint in 'Foo'
 def Foo : TestInstructionWithConstraints<"@earlyclobber ">;

llvm/test/TableGen/ConstraintChecking3.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
 // (This is illegal because the '=' has to be surrounded by whitespace)
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Illegal format for tied-to constraint in 'Foo'
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Illegal format for tied-to constraint in 'Foo'
 def Foo : TestInstructionWithConstraints<"$dest1=$dest2">;

llvm/test/TableGen/ConstraintChecking4.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Output operands '$dest1' and '$dest2' of 'Foo' cannot be tied!
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Output operands '$dest1' and '$dest2' of 'Foo' cannot be tied!
 def Foo : TestInstructionWithConstraints<"$dest1 = $dest2">;

llvm/test/TableGen/ConstraintChecking5.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Input operands '$src1' and '$src2' of 'Foo' cannot be tied!
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Input operands '$src1' and '$src2' of 'Foo' cannot be tied!
 def Foo : TestInstructionWithConstraints<"$src1 = $src2">;

llvm/test/TableGen/ConstraintChecking6.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$dest1' of 'Foo' cannot have multiple operands tied to it!
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Operand '$dest1' of 'Foo' cannot have multiple operands tied to it!
 def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest1 = $src2">;

llvm/test/TableGen/ConstraintChecking7.td

 // RUN: not llvm-tblgen -gen-asm-writer -I %p -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "ConstraintChecking.inc"
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: Operand '$src1' of 'Foo' cannot have multiple constraints!
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: Operand '$src1' of 'Foo' cannot have multiple constraints!
 def Foo : TestInstructionWithConstraints<"$dest1 = $src1, $dest2 = $src1">;

llvm/test/TableGen/GlobalISelEmitter-setcc.td

 // GISEL: GIM_Try
 // GISEL: GIM_CheckNumOperands, /*MI*/0, /*Expected*/4,
 // GISEL-NEXT: GIM_CheckOpcode, /*MI*/0, TargetOpcode::G_ICMP,
 // GISEL: GIM_CheckCmpPredicate, /*MI*/0, /*Op*/1, /*Predicate*/CmpInst::ICMP_EQ,
 def ICMPEQ : I<(outs GPR32:$dst), (ins GPR32Op:$src0, GPR32:$src1),
                [(set GPR32:$dst, (i32 (setcc i32:$src0, i32:$src1, SETEQ)))]>;
 
 // Check there is an error if not a CondCode operand.
-// ERR: [[FILE]]:[[@LINE+1]]:1: warning: Skipped pattern: Unable to handle CondCode
+// ERR: [[FILE]]:[[@LINE+1]]:5: warning: Skipped pattern: Unable to handle CondCode
 def FCMP_NOTCC : I<(outs GPR32:$dst), (ins FPR32Op:$src0, FPR32:$src1),
                    [(set GPR32:$dst, (i32 (setcc f32:$src0, f32:$src1, i32)))]>;

llvm/test/TableGen/RegisterClass.td

 // RUN: not llvm-tblgen -gen-register-bank -I %p/../../include %s 2>&1 | FileCheck %s
 
 include "llvm/Target/Target.td"
 
 def MyTarget : Target;
 def R0 : Register<"r0">;
-def ClassA : RegisterClass<"MyTarget", [], 32, (add R0)>; // CHECK: [[@LINE]]:1: error: RegTypes list must not be empty!
+def ClassA : RegisterClass<"MyTarget", [], 32, (add R0)>; // CHECK: [[@LINE]]:5: error: RegTypes list must not be empty!

llvm/test/TableGen/SchedModelError.td

 // RUN: not llvm-tblgen -gen-subtarget -I %p/../../include %s 2>&1 | FileCheck %s -DFILE=%s
 
 include "llvm/Target/Target.td"
 
 def TestTarget : Target;
 
-// CHECK: [[FILE]]:[[@LINE+1]]:1: error: No schedule information for instruction 'TestInst' in SchedMachineModel 'TestSchedModel'
+// CHECK: [[FILE]]:[[@LINE+1]]:5: error: No schedule information for instruction 'TestInst' in SchedMachineModel 'TestSchedModel'
 def TestInst : Instruction {
   let OutOperandList = (outs);
   let InOperandList = (ins);
   bits<8> Inst = 0b00101010;
 }
 
 def TestSchedModel : SchedMachineModel {
   let CompleteModel = 1;
 }
 
 def TestProcessor : ProcessorModel<"testprocessor", TestSchedModel, []>;

llvm/test/TableGen/generic-tables.td

 #ifdef ERROR1
 
 class DEntry<string str, int val1> {
   string Str = str;
   bits<8> Val1 = val1;
 }
 
 def DFoo : DEntry<"foo", 1>;
-// ERROR1: [[@LINE+1]]:1: error: Record 'DBar' for table 'DTable' is missing field 'Val1'
+// ERROR1: [[@LINE+1]]:5: error: Record 'DBar' for table 'DTable' is missing field 'Val1'
 def DBar : DEntry<"bar", ?>;
 
 def DTable : GenericTable {
   let FilterClass = "DEntry";
   let Fields = ["Str", "Val1"];
 }
 
 #endif // ERROR1

mlir/lib/Tools/tblgen-lsp-server/TableGenServer.cpp

auto defs =
       llvm::make_pointee_range(llvm::make_second_range(records.getDefs()));
   for (const llvm::Record &def : llvm::concat<llvm::Record>(classes, defs)) {
     auto *sym = getOrInsertDef(&def);
     insertRef(sym, sym->defLoc, /*isDef=*/true);
 
     // Add references to the definition.
     for (SMLoc loc : def.getLoc().drop_front())
       insertRef(sym, lsp::convertTokenLocToRange(loc));
-
-    // Add references to any super classes.
-    for (auto &it : def.getSuperClasses())
-      insertRef(getOrInsertDef(it.first),
-                lsp::convertTokenLocToRange(it.second.Start));
+    for (SMRange loc : def.getReferenceLocs())
+      insertRef(sym, loc);
 
     // Add definitions for any values.
     for (const llvm::RecordVal &value : def.getValues()) {
       auto *sym = getOrInsertDef(&value);
       insertRef(sym, sym->defLoc, /*isDef=*/true);
+      for (SMRange refLoc : value.getReferenceLocs())
+        insertRef(sym, refLoc);
     }
   }
 }
 
 const TableGenIndexSymbol *
 TableGenIndex::lookup(SMLoc loc, SMRange *overlappedRange) const {
   auto it = intervalMap.find(loc.getPointer());
   if (!it.valid() || loc.getPointer() < it.start())