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. raw()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 66