clang-tools-extra/clangd/ExpectedTypes.h

   1 //===--- ExpectedTypes.h - Simplified C++ types -----------------*- C++-*--===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // A simplified model of C++ types that can be used to check whether they are
   9 // convertible between each other for the purposes of code completion ranking
  10 // without looking at the ASTs. Note that we don't aim to fully mimic the C++
  11 // conversion rules, merely try to have a model that gives useful improvements
  12 // to the code completion ranking.
  13 //
  14 // We define an encoding of AST types as opaque strings, which can be stored in
  15 // the index. Similar types (such as `int` and `long`) are folded together,
  16 // forming equivalence classes with the same encoding.
  17 //===----------------------------------------------------------------------===//
  18 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTEDTYPES_H
  19 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTEDTYPES_H
  20
  21 #include "clang/AST/Type.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include <optional>
  24
  25 namespace clang {
  26 class CodeCompletionResult;
  27
  28 namespace clangd {
  29 /// A representation of a type that can be computed based on clang AST and
  30 /// compared for equality. The encoding is stable between different ASTs, this
  31 /// allows the representation to be stored in the index and compared with types
  32 /// coming from a different AST later.
  33 /// OpaqueType is a strongly-typedefed std::string, you can get the underlying
  34 /// string with raw().
  35 class OpaqueType {
  36 public:
  37   /// Create a type from a code completion result.
  38   static std::optional<OpaqueType>
  39   fromCompletionResult(ASTContext &Ctx, const CodeCompletionResult &R);
  40   /// Construct an instance from a clang::QualType. This is usually a
  41   /// PreferredType from a clang's completion context.
  42   static std::optional<OpaqueType> fromType(ASTContext &Ctx, QualType Type);
  43
  44   /// Get the raw byte representation of the type. You can only rely on the
  45   /// types being equal iff their raw representation is the same. The particular
  46   /// details of the used encoding might change over time and one should not
  47   /// rely on it.
  48   llvm::StringRef raw() const { return Data; }
  49
  50   friend bool operator==(const OpaqueType &L, const OpaqueType &R) {
  51     return L.Data == R.Data;
  52   }
  53   friend bool operator!=(const OpaqueType &L, const OpaqueType &R) {
  54     return !(L == R);
  55   }
  56
  57 private:
  58   static std::optional<OpaqueType> encode(ASTContext &Ctx, QualType Type);
  59   explicit OpaqueType(std::string Data);
  60
  61   std::string Data;
  62 };
  63 } // namespace clangd
  64 } // namespace clang
  65 #endif