[TableGen:LSP] Add hover support for records and recordvals

[rriddle]

Summary

This provides hover information for classes, defs, fields, and template
arguments. Like PDLL, this pulls documentation from the source code
when hovering over fields and records.

[rriddle]

Screenshots from vscode:

[jpienaar]

Nice, thanks

mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp

103

Should we skip over lines with TODO and FIXME? I'm thinking of the case of comment describing function followed by TODO, where the latter normally doesn't add much doc info.

(Not required and there may not be enough of these to warrant extra complexity for now)

[rriddle]

mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp

103

I don't think we should mostly given that clangd doesn't either. I've tried to model the same behavior there as much as possible, so that it's less surprising when you switch between languages.

mlir/docs/Tools/MLIRLSP.md

 ![IMG](/tblgen-lsp-server/goto_def.gif)
 
 ##### Find references
 
 Show all references of the symbol under the cursor.
 
 ![IMG](/tblgen-lsp-server/find_references.gif)
 
+#### Hover
+
+Hover over a symbol to see more information about it, such as its type,
+documentation, and more.
+
+![IMG](/tblgen-lsp-server/hover_def.png)
+
+Hovering over an overridden field will also show you information such as
+documentation from the base value:
+
+![IMG](/tblgen-lsp-server/hover_field.png)
+
 ## Language Server Design
 
 The design of the various language servers provided by MLIR are effectively the
 same, and are largely comprised of three different components:
 
 - Communication and Transport (via JSON-RPC)
 - Language Server Protocol
 - Language-Specific Server

mlir/lib/Tools/lsp-server-support/SourceMgrUtils.h

 // Utils
 //===----------------------------------------------------------------------===//
 
 /// Returns the range of a lexical token given a SMLoc corresponding to the
 /// start of an token location. The range is computed heuristically, and
 /// supports identifier-like tokens, strings, etc.
 SMRange convertTokenLocToRange(SMLoc loc);
 
+/// Extract a documentation comment for the given location within the source
+/// manager. Returns None if no comment could be computed.
+Optional<std::string> extractSourceDocComment(llvm::SourceMgr &sourceMgr,
+                                              SMLoc loc);
+
 //===----------------------------------------------------------------------===//
 // SourceMgrInclude
 //===----------------------------------------------------------------------===//
 
 /// This class represents a single include within a root file.
 struct SourceMgrInclude {
   SourceMgrInclude(const lsp::URIForFile &uri, const lsp::Range &range)
       : uri(uri), range(range) {}

mlir/lib/Tools/lsp-server-support/SourceMgrUtils.cpp

if (*curPtr == '"') {
 
     while (*curPtr && isIdentifierChar(*(++curPtr)))
       continue;
   }
 
   return SMRange(loc, SMLoc::getFromPointer(curPtr));
 }
 
+Optional<std::string> lsp::extractSourceDocComment(llvm::SourceMgr &sourceMgr,
+                                                   SMLoc loc) {
+  // This is a heuristic, and isn't intended to cover every case, but should
+  // cover the most common. We essentially look for a comment preceding the
+  // line, and if we find one, use that as the documentation.
+  if (!loc.isValid())
+    return llvm::None;
+  int bufferId = sourceMgr.FindBufferContainingLoc(loc);
+  if (bufferId == 0)
+    return llvm::None;
+  const char *bufferStart =
+      sourceMgr.getMemoryBuffer(bufferId)->getBufferStart();
+  StringRef buffer(bufferStart, loc.getPointer() - bufferStart);
+
+  // Pop the last line from the buffer string.
+  auto popLastLine = [&]() -> Optional<StringRef> {
+    size_t newlineOffset = buffer.find_last_of("\n");
+    if (newlineOffset == StringRef::npos)
+      return llvm::None;
+    StringRef lastLine = buffer.drop_front(newlineOffset).trim();
+    buffer = buffer.take_front(newlineOffset);
+    return lastLine;
+  };
+
+  // Try to pop the current line.
+  if (!popLastLine())
+    return llvm::None;
+
+  // Try to parse a comment string from the source file.
+  SmallVector<StringRef> commentLines;
+  while (Optional<StringRef> line = popLastLine()) {
+    // Check for a comment at the beginning of the line.
+    if (!line->startswith("//"))
+      break;
+
+    // Extract the document string from the comment.
+    commentLines.push_back(line->drop_while([](char c) { return c == '/'; }));
+  }
+
+  if (commentLines.empty())
+    return llvm::None;
+  return llvm::join(llvm::reverse(commentLines), "\n");
+}
+
 //===----------------------------------------------------------------------===//
 // SourceMgrInclude
 //===----------------------------------------------------------------------===//
 
 Hover SourceMgrInclude::buildHover() const {
   Hover hover(range);
   {
     llvm::raw_string_ostream hoverOS(hover.contents.value);

mlir/lib/Tools/mlir-pdll-lsp-server/PDLLServer.cpp

 /// Get or extract the documentation for the given decl.
 static Optional<std::string> getDocumentationFor(llvm::SourceMgr &sourceMgr,
                                                  const ast::Decl *decl) {
   // If the decl already had documentation set, use it.
   if (Optional<StringRef> doc = decl->getDocComment())
     return doc->str();
 
   // If the decl doesn't yet have documentation, try to extract it from the
-  // source file. This is a heuristic, and isn't intended to cover every case,
-  // but should cover the most common. We essentially look for a comment
-  // preceding the decl, and if we find one, use that as the documentation.
-  SMLoc startLoc = decl->getLoc().Start;
-  if (!startLoc.isValid())
-    return llvm::None;
-  int bufferId = sourceMgr.FindBufferContainingLoc(startLoc);
-  if (bufferId == 0)
-    return llvm::None;
-  const char *bufferStart =
-      sourceMgr.getMemoryBuffer(bufferId)->getBufferStart();
-  StringRef buffer(bufferStart, startLoc.getPointer() - bufferStart);
-
-  // Pop the last line from the buffer string.
-  auto popLastLine = [&]() -> Optional<StringRef> {
-    size_t newlineOffset = buffer.find_last_of("\n");
-    if (newlineOffset == StringRef::npos)
-      return llvm::None;
-    StringRef lastLine = buffer.drop_front(newlineOffset).trim();
-    buffer = buffer.take_front(newlineOffset);
-    return lastLine;
-  };
-
-  // Try to pop the current line, which contains the decl.
-  if (!popLastLine())
-    return llvm::None;
-
-  // Try to parse a comment string from the source file.
-  SmallVector<StringRef> commentLines;
-  while (Optional<StringRef> line = popLastLine()) {
-    // Check for a comment at the beginning of the line.
-    if (!line->startswith("//"))
-      break;
-
-    // Extract the document string from the comment.
-    commentLines.push_back(line->drop_while([](char c) { return c == '/'; }));
-  }
-
-  if (commentLines.empty())
-    return llvm::None;
-  return llvm::join(llvm::reverse(commentLines), "\n");
+  // source file.
+  return lsp::extractSourceDocComment(sourceMgr, decl->getLoc().Start);
 }
 
 //===----------------------------------------------------------------------===//
 // PDLIndex
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct PDLIndexSymbol {

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

 //===- TableGenServer.cpp - TableGen Language Server ----------------------===//
 //
 // 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 "TableGenServer.h"
 
 #include "../lsp-server-support/CompilationDatabase.h"
 #include "../lsp-server-support/Logging.h"
 #include "../lsp-server-support/Protocol.h"
 #include "../lsp-server-support/SourceMgrUtils.h"
+#include "mlir/Support/IndentedOstream.h"
 #include "mlir/Support/LogicalResult.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
case llvm::SourceMgr::DK_Remark:
     lspDiag.severity = lsp::DiagnosticSeverity::Information;
     break;
   }
   lspDiag.message = diag.getMessage().str();
 
   return lspDiag;
 }
 
+/// Get the base definition of the given record value, or nullptr if one
+/// couldn't be found.
+static std::pair<const llvm::Record *, const llvm::RecordVal *>
+getBaseValue(const llvm::Record *record, const llvm::RecordVal *value) {
+  if (value->isTemplateArg())
+    return {nullptr, nullptr};
+
+  // Find a base value for the field in the super classes of the given record.
+  // On success, `record` is updated to the new parent record.
+  StringRef valueName = value->getName();
+  auto findValueInSupers =
+      [&](const llvm::Record *&record) -> llvm::RecordVal * {
+    for (auto [parentRecord, loc] : record->getSuperClasses()) {
+      if (auto *newBase = parentRecord->getValue(valueName)) {
+        record = parentRecord;
+        return newBase;
+      }
+    }
+    return nullptr;
+  };
+
+  // Try to find the lowest definition of the record value.
+  std::pair<const llvm::Record *, const llvm::RecordVal *> baseValue = {};
+  while (const llvm::RecordVal *newBase = findValueInSupers(record))
+    baseValue = {record, newBase};
+
+  // Check that the base isn't the same as the current value (e.g. if the value
+  // wasn't overridden).
+  if (!baseValue.second || baseValue.second->getLoc() == value->getLoc())
+    return {nullptr, nullptr};
+  return baseValue;
+}
+
 //===----------------------------------------------------------------------===//
 // TableGenIndex
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class represents a single symbol definition within a TableGen index. It
 /// contains the definition of the symbol, the location of the symbol, and any
 /// recorded references.
 struct TableGenIndexSymbol {
   TableGenIndexSymbol(const llvm::Record *record)
       : definition(record),
         defLoc(lsp::convertTokenLocToRange(record->getLoc().front())) {}
   TableGenIndexSymbol(const llvm::RecordVal *value)
       : definition(value),
         defLoc(lsp::convertTokenLocToRange(value->getLoc())) {}
 
-  /// The main definition of the symbol.
+  // The main definition of the symbol.
   PointerUnion<const llvm::Record *, const llvm::RecordVal *> definition;
 
   /// The source location of the definition.
   SMRange defLoc;
 
   /// The source location of the references of the definition.
   SmallVector<SMRange> references;
 };
+/// This class represents a single record symbol.
+struct TableGenRecordSymbol : public TableGenIndexSymbol {
+  TableGenRecordSymbol(const llvm::Record *record)
+      : TableGenIndexSymbol(record) {}
+
+  static bool classof(const TableGenIndexSymbol *symbol) {
+    return symbol->definition.is<const llvm::Record *>();
+  }
+
+  /// Return the value of this symbol.
+  const llvm::Record *getValue() const {
+    return definition.get<const llvm::Record *>();
+  }
+};
+/// This class represents a single record value symbol.
+struct TableGenRecordValSymbol : public TableGenIndexSymbol {
+  TableGenRecordValSymbol(const llvm::Record *record,
+                          const llvm::RecordVal *value)
+      : TableGenIndexSymbol(value), record(record) {}
+
+  static bool classof(const TableGenIndexSymbol *symbol) {
+    return symbol->definition.is<const llvm::RecordVal *>();
+  }
+
+  /// Return the value of this symbol.
+  const llvm::RecordVal *getValue() const {
+    return definition.get<const llvm::RecordVal *>();
+  }
+
+  /// The parent record of this symbol.
+  const llvm::Record *record;
+};
 
 /// This class provides an index for definitions/uses within a TableGen
 /// document. It provides efficient lookup of a definition given an input source
 /// range.
 class TableGenIndex {
 public:
   TableGenIndex() : intervalMap(allocator) {}
 
private:
   /// The type of interval map used to store source references. SMRange is
   /// half-open, so we also need to use a half-open interval map.
   using MapT = llvm::IntervalMap<
       const char *, const TableGenIndexSymbol *,
       llvm::IntervalMapImpl::NodeSizer<const char *,
                                        const TableGenIndexSymbol *>::LeafSize,
       llvm::IntervalMapHalfOpenInfo<const char *>>;
 
+  /// Get or insert a symbol for the given record.
+  TableGenIndexSymbol *getOrInsertDef(const llvm::Record *record) {
+    auto it = defToSymbol.try_emplace(record, nullptr);
+    if (it.second)
+      it.first->second = std::make_unique<TableGenRecordSymbol>(record);
+    return &*it.first->second;
+  }
+  /// Get or insert a symbol for the given record value.
+  TableGenIndexSymbol *getOrInsertDef(const llvm::Record *record,
+                                      const llvm::RecordVal *value) {
+    auto it = defToSymbol.try_emplace(value, nullptr);
+    if (it.second) {
+      it.first->second =
+          std::make_unique<TableGenRecordValSymbol>(record, value);
+    }
+    return &*it.first->second;
+  }
+
   /// An allocator for the interval map.
   MapT::Allocator allocator;
 
   /// An interval map containing a corresponding definition mapped to a source
   /// interval.
   MapT intervalMap;
 
   /// A mapping between definitions and their corresponding symbol.
   DenseMap<const void *, std::unique_ptr<TableGenIndexSymbol>> defToSymbol;
 };
 } // namespace
 
 void TableGenIndex::initialize(const llvm::RecordKeeper &records) {
-  auto getOrInsertDef = [&](const auto *def) -> TableGenIndexSymbol * {
-    auto it = defToSymbol.try_emplace(def, nullptr);
-    if (it.second)
-      it.first->second = std::make_unique<TableGenIndexSymbol>(def);
-    return &*it.first->second;
-  };
   auto insertRef = [&](TableGenIndexSymbol *sym, SMRange refLoc,
                        bool isDef = false) {
     const char *startLoc = refLoc.Start.getPointer();
     const char *endLoc = refLoc.End.getPointer();
 
     // If the location we got was empty, try to lex a token from the start
     // location.
     if (startLoc == endLoc) {
for (const llvm::Record &def : llvm::concat<llvm::Record>(classes, defs)) {
     // Add references to the definition.
     for (SMLoc loc : def.getLoc().drop_front())
       insertRef(sym, lsp::convertTokenLocToRange(loc));
     for (SMRange loc : def.getReferenceLocs())
       insertRef(sym, loc);
 
     // Add definitions for any values.
     for (const llvm::RecordVal &value : def.getValues()) {
-      auto *sym = getOrInsertDef(&value);
+      auto *sym = getOrInsertDef(&def, &value);
       insertRef(sym, sym->defLoc, /*isDef=*/true);
       for (SMRange refLoc : value.getReferenceLocs())
         insertRef(sym, refLoc);
     }
   }
 }
 
 const TableGenIndexSymbol *
void getDocumentLinks(const lsp::URIForFile &uri,
                         std::vector<lsp::DocumentLink> &links);
 
   //===--------------------------------------------------------------------===//
   // Hover
   //===--------------------------------------------------------------------===//
 
   Optional<lsp::Hover> findHover(const lsp::URIForFile &uri,
                                  const lsp::Position &hoverPos);
+  lsp::Hover buildHoverForRecord(const llvm::Record *record,
+                                 const SMRange &hoverRange);
+  lsp::Hover buildHoverForTemplateArg(const llvm::Record *record,
+                                      const llvm::RecordVal *value,
+                                      const SMRange &hoverRange);
+  lsp::Hover buildHoverForField(const llvm::Record *record,
+                                const llvm::RecordVal *value,
+                                const SMRange &hoverRange);
 
 private:
   /// Initialize the text file from the given file contents.
   void initialize(const lsp::URIForFile &uri, int64_t newVersion,
                   std::vector<lsp::Diagnostic> &diagnostics);
 
   /// The full string contents of the file.
   std::string contents;

 
 Optional<lsp::Hover>
 TableGenTextFile::findHover(const lsp::URIForFile &uri,
                             const lsp::Position &hoverPos) {
   // Check for a reference to an include.
   for (const lsp::SourceMgrInclude &include : parsedIncludes)
     if (include.range.contains(hoverPos))
       return include.buildHover();
+
+  // Find the symbol at the given location.
+  SMRange hoverRange;
+  SMLoc posLoc = hoverPos.getAsSMLoc(sourceMgr);
+  const TableGenIndexSymbol *symbol = index.lookup(posLoc, &hoverRange);
+  if (!symbol)
     return llvm::None;
+
+  // Build hover for a Record.
+  if (auto *record = dyn_cast<TableGenRecordSymbol>(symbol))
+    return buildHoverForRecord(record->getValue(), hoverRange);
+
+  // Build hover for a RecordVal, which is either a template argument or a
+  // field.
+  auto *recordVal = cast<TableGenRecordValSymbol>(symbol);
+  const llvm::RecordVal *value = recordVal->getValue();
+  if (value->isTemplateArg())
+    return buildHoverForTemplateArg(recordVal->record, value, hoverRange);
+  return buildHoverForField(recordVal->record, value, hoverRange);
+}
+
+lsp::Hover TableGenTextFile::buildHoverForRecord(const llvm::Record *record,
+                                                 const SMRange &hoverRange) {
+  lsp::Hover hover(lsp::Range(sourceMgr, hoverRange));
+  {
+    llvm::raw_string_ostream hoverOS(hover.contents.value);
+
+    // Format the type of record this is.
+    if (record->isClass()) {
+      hoverOS << "**class** `" << record->getName() << "`";
+    } else if (record->isAnonymous()) {
+      hoverOS << "**anonymous class**";
+    } else {
+      hoverOS << "**def** `" << record->getName() << "`";
+    }
+    hoverOS << "\n***\n";
+
+    // Check if this record has summary/description fields. These are often used
+    // to hold documentation for the record.
+    auto printAndFormatField = [&](StringRef fieldName) {
+      // Check that the record actually has the given field, and that it's a
+      // string.
+      const llvm::RecordVal *value = record->getValue(fieldName);
+      if (!value || !value->getValue())
+        return;
+      auto *stringValue = dyn_cast<llvm::StringInit>(value->getValue());
+      if (!stringValue)
+        return;
+
+      raw_indented_ostream ros(hoverOS);
+      ros.printReindented(stringValue->getValue().rtrim(" \t"));
+      hoverOS << "\n***\n";
+    };
+    printAndFormatField("summary");
+    printAndFormatField("description");
+
+    // Check for documentation in the source file.
+    if (Optional<std::string> doc =
+            lsp::extractSourceDocComment(sourceMgr, record->getLoc().front())) {
+      hoverOS << "\n" << *doc << "\n";
+    }
+  }
+  return hover;
+}
+
+lsp::Hover
+TableGenTextFile::buildHoverForTemplateArg(const llvm::Record *record,
+                                           const llvm::RecordVal *value,
+                                           const SMRange &hoverRange) {
+  lsp::Hover hover(lsp::Range(sourceMgr, hoverRange));
+  {
+    llvm::raw_string_ostream hoverOS(hover.contents.value);
+    StringRef name = value->getName().rsplit(':').second;
+
+    hoverOS << "**template arg** `" << name << "`\n***\nType: `";
+    value->getType()->print(hoverOS);
+    hoverOS << "`\n";
+  }
+  return hover;
+}
+
+lsp::Hover TableGenTextFile::buildHoverForField(const llvm::Record *record,
+                                                const llvm::RecordVal *value,
+                                                const SMRange &hoverRange) {
+  lsp::Hover hover(lsp::Range(sourceMgr, hoverRange));
+  {
+    llvm::raw_string_ostream hoverOS(hover.contents.value);
+    hoverOS << "**field** `" << value->getName() << "`\n***\nType: `";
+    value->getType()->print(hoverOS);
+    hoverOS << "`\n***\n";
+
+    // Check for documentation in the source file.
+    if (Optional<std::string> doc =
+            lsp::extractSourceDocComment(sourceMgr, value->getLoc())) {
+      hoverOS << "\n" << *doc << "\n";
+      hoverOS << "\n***\n";
+    }
+
+    // Check to see if there is a base value that we can use for
+    // documentation.
+    auto [baseRecord, baseValue] = getBaseValue(record, value);
+    if (baseValue) {
+      if (Optional<std::string> doc =
+              lsp::extractSourceDocComment(sourceMgr, baseValue->getLoc())) {
+        hoverOS << "\n *From `" << baseRecord->getName() << "`*:\n\n"
+                << *doc << "\n";
+      }
+    }
+  }
+  return hover;
 }
 
 //===----------------------------------------------------------------------===//
 // TableGenServer::Impl
 //===----------------------------------------------------------------------===//
 
 struct lsp::TableGenServer::Impl {
   explicit Impl(const Options &options)

mlir/test/tblgen-lsp-server/hover.test

 // RUN: tblgen-lsp-server -tablegen-extra-dir %S -tablegen-extra-dir %S/../../include -lit-test < %s | FileCheck %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"tablegen","capabilities":{},"trace":"off"}}
 // -----
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{
   "uri":"test:///foo.td",
   "languageId":"tablegen",
   "version":1,
-  "text":"include \"include/included.td\""
+  "text":"include \"include/included.td\"\n// This is a def.\ndef Def : IncludedClass;\nclass Class<IncludedClass c> {\n  int arg = c.arg;\n}\n"
 }}}
 // -----
 // Hover on an include file.
 {"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
   "textDocument":{"uri":"test:///foo.td"},
   "position":{"line":0,"character":15}
 }}
 //      CHECK:  "id": 1,

 // CHECK-NEXT:      },
 // CHECK-NEXT:      "start": {
 // CHECK-NEXT:        "character": 8,
 // CHECK-NEXT:        "line": 0
 // CHECK-NEXT:      }
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 // -----
+// Hover on a record.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.td"},
+  "position":{"line":2,"character":6}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "**def** `Def`\n***\n\n This is a def.\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 7,
+// CHECK-NEXT:        "line": 2
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 4,
+// CHECK-NEXT:        "line": 2
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
+// Hover on a record.
+{"jsonrpc":"2.0","id":1,"method":"textDocument/hover","params":{
+  "textDocument":{"uri":"test:///foo.td"},
+  "position":{"line":4,"character":16}
+}}
+//      CHECK:  "id": 1,
+// CHECK-NEXT:  "jsonrpc": "2.0",
+// CHECK-NEXT:  "result": {
+// CHECK-NEXT:    "contents": {
+// CHECK-NEXT:      "kind": "markdown",
+// CHECK-NEXT:      "value": "**field** `arg`\n***\nType: `int`\n***\n\n This argument was defined on an included class.\n\n***\n"
+// CHECK-NEXT:    },
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:      "end": {
+// CHECK-NEXT:        "character": 17,
+// CHECK-NEXT:        "line": 4
+// CHECK-NEXT:      },
+// CHECK-NEXT:      "start": {
+// CHECK-NEXT:        "character": 14,
+// CHECK-NEXT:        "line": 4
+// CHECK-NEXT:      }
+// CHECK-NEXT:    }
+// CHECK-NEXT:  }
+// -----
 {"jsonrpc":"2.0","id":7,"method":"shutdown"}
 // -----
 {"jsonrpc":"2.0","method":"exit"}

mlir/test/tblgen-lsp-server/include/included.td

 
 // This file is merely to test the processing of includes, it has
-// no other purpose or contents.
+// no other purpose.
+
+class IncludedClass {
+  /// This argument was defined on an included class.
+  int arg = 10;
+}