[clangd] Another improvement for std include mapping.

[hokein]

Summary

Improve the way of checking a symbol name is in the first cell. The previous way
is not very robost for cases where a cell lists multiple symbols (e.g. int8_t).

clang-tools-extra/trunk/clangd/StdSymbolMap.inc

 SYMBOL(in_place_index_t, std::, <utility>)
 SYMBOL(in_place_t, std::, <utility>)
 SYMBOL(in_place_type, std::, <utility>)
 SYMBOL(in_place_type_t, std::, <utility>)
 SYMBOL(includes, std::, <algorithm>)
 SYMBOL(inclusive_scan, std::, <numeric>)
 SYMBOL(independent_bits_engine, std::, <random>)
 SYMBOL(indirect_array, std::, <valarray>)
+SYMBOL(initializer_list, std::, <initializer_list>)
 SYMBOL(inner_product, std::, <numeric>)
 SYMBOL(inplace_merge, std::, <algorithm>)
 SYMBOL(input_iterator_tag, std::, <iterator>)
 SYMBOL(insert_iterator, std::, <iterator>)
 SYMBOL(inserter, std::, <iterator>)
+SYMBOL(int16_t, std::, <cstdint>)
+SYMBOL(int32_t, std::, <cstdint>)
+SYMBOL(int64_t, std::, <cstdint>)
+SYMBOL(int8_t, std::, <cstdint>)
+SYMBOL(int_fast16_t, std::, <cstdint>)
+SYMBOL(int_fast32_t, std::, <cstdint>)
+SYMBOL(int_fast64_t, std::, <cstdint>)
+SYMBOL(int_fast8_t, std::, <cstdint>)
+SYMBOL(int_least16_t, std::, <cstdint>)
+SYMBOL(int_least32_t, std::, <cstdint>)
+SYMBOL(int_least64_t, std::, <cstdint>)
+SYMBOL(int_least8_t, std::, <cstdint>)
 SYMBOL(integer_sequence, std::, <utility>)
 SYMBOL(integral_constant, std::, <type_traits>)
 SYMBOL(internal, std::, <ios>)
 SYMBOL(intmax_t, std::, <cstdint>)
 SYMBOL(intptr_t, std::, <cstdint>)
 SYMBOL(invalid_argument, std::, <stdexcept>)
 SYMBOL(invoke, std::, <functional>)
 SYMBOL(invoke_result, std::, <type_traits>)

 SYMBOL(type_index, std::, <typeindex>)
 SYMBOL(type_info, std::, <typeinfo>)
 SYMBOL(u16streampos, std::, <ios>)
 SYMBOL(u16string, std::, <string>)
 SYMBOL(u16string_view, std::, <string_view>)
 SYMBOL(u32streampos, std::, <ios>)
 SYMBOL(u32string, std::, <string>)
 SYMBOL(u32string_view, std::, <string_view>)
+SYMBOL(uint16_t, std::, <cstdint>)
+SYMBOL(uint32_t, std::, <cstdint>)
+SYMBOL(uint64_t, std::, <cstdint>)
+SYMBOL(uint8_t, std::, <cstdint>)
+SYMBOL(uint_fast16_t, std::, <cstdint>)
+SYMBOL(uint_fast32_t, std::, <cstdint>)
+SYMBOL(uint_fast64_t, std::, <cstdint>)
+SYMBOL(uint_fast8_t, std::, <cstdint>)
+SYMBOL(uint_least16_t, std::, <cstdint>)
+SYMBOL(uint_least32_t, std::, <cstdint>)
+SYMBOL(uint_least64_t, std::, <cstdint>)
+SYMBOL(uint_least8_t, std::, <cstdint>)
 SYMBOL(uintmax_t, std::, <cstdint>)
 SYMBOL(uintptr_t, std::, <cstdint>)
 SYMBOL(uncaught_exceptions, std::, <exception>)
 SYMBOL(undeclare_no_pointers, std::, <memory>)
 SYMBOL(undeclare_reachable, std::, <memory>)
 SYMBOL(underflow_error, std::, <stdexcept>)
 SYMBOL(underlying_type, std::, <type_traits>)
 SYMBOL(underlying_type_t, std::, <type_traits>)

clang-tools-extra/trunk/clangd/include-mapping/gen_std.py

def ParseSymbolPage(symbol_page_html, symbol_name):
   #   Defined in header <baz>      .t-dsc-header
   #   decl2                        .t-dcl
   for table in soup.select('table.t-dcl-begin, table.t-dsc-begin'):
     current_headers = []
     was_decl = False
     for row in table.select('tr'):
       if HasClass(row, 't-dcl', 't-dsc'):
         was_decl = True
-        # Declaration is in the first cell.
-        text = row.find('td').text
-        # Decl may not be for the symbol name we're looking for.
-        if not re.search("\\b%s\\b" % symbol_name, text):
+        # Symbols are in the first cell.
+        found_symbols = row.find('td').stripped_strings
+        if not symbol_name in found_symbols:
           continue
         headers.update(current_headers)
       elif HasClass(row, 't-dsc-header'):
         # If we saw a decl since the last header, this is a new block of headers
         # for a new block of decls.
         if was_decl:
           current_headers = []
         was_decl = False

clang-tools-extra/trunk/clangd/include-mapping/test.py

<table class="t-dcl-begin"><tbody>
   </tr>
   <tr class="t-dsc-header">
     <td> <div>Defined in header <code><a href=".cstdlib.html" title="ccstdlib">&lt;cstdlib&gt;</a></code>
      </div></td>
     <td></td>
     <td></td>
   </tr>
   <tr class="t-dcl">
-    <td>void foo()</td>
+    <td>
+      <span>void</span>
+      foo
+      <span>()</span>
+    </td>
     <td>this is matched</td>
   </tr>
 </tbody></table>
 """
     self.assertEqual(ParseSymbolPage(html, "foo"),
                      set(['<cstdio>', '<cstdlib>']))
 
 
   def testParseSymbolPage_MulHeadersInSameDiv(self):
     # Multile <code> blocks in a Div.
     # Defined in header <algorithm>
     # Defined in header <utility>
     html = """
 <table class="t-dcl-begin"><tbody>
 <tr class="t-dsc-header">
 <td><div>
      Defined in header <code><a href="../header/algorithm.html" title="cpp/header/algorithm">&lt;algorithm&gt;</a></code><br>
      Defined in header <code><a href="../header/utility.html" title="cpp/header/utility">&lt;utility&gt;</a></code>
 </div></td>
 <td></td>
 </tr>
 <tr class="t-dcl">
-  <td>void foo()</td>
+  <td>
+    <span>void</span>
+    foo
+    <span>()</span>
+  </td>
   <td>this is matched</td>
 </tr>
 </tbody></table>
 """
     self.assertEqual(ParseSymbolPage(html, "foo"),
                      set(['<algorithm>', '<utility>']))
 
+  def testParseSymbolPage_MulSymbolsInSameTd(self):
+    # defined in header <cstdint>
+    #   int8_t
+    #   int16_t
+    html = """
+<table class="t-dcl-begin"><tbody>
+<tr class="t-dsc-header">
+<td><div>
+     Defined in header <code><a href="cstdint.html" title="cstdint">&lt;cstdint&gt;</a></code><br>
+</div></td>
+<td></td>
+</tr>
+<tr class="t-dcl">
+  <td>
+    <span>int8_t</span>
+    <span>int16_t</span>
+  </td>
+  <td>this is matched</td>
+</tr>
+</tbody></table>
+"""
+    self.assertEqual(ParseSymbolPage(html, "int8_t"),
+                     set(['<cstdint>']))
+    self.assertEqual(ParseSymbolPage(html, "int16_t"),
+                     set(['<cstdint>']))
+
 
 if __name__ == '__main__':
   unittest.main()