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_EXPECTED_TYPES_H 19 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_EXPECTED_TYPES_H 20 21 #include "clang/AST/Type.h" 22 #include "llvm/ADT/StringRef.h" 23 24 namespace clang { 25 class CodeCompletionResult; 26 27 namespace clangd { 28 /// A representation of a type that can be computed based on clang AST and 29 /// compared for equality. The encoding is stable between different ASTs, this 30 /// allows the representation to be stored in the index and compared with types 31 /// coming from a different AST later. 32 /// OpaqueType is a strongly-typedefed std::string, you can get the underlying 33 /// string with raw(). 34 class OpaqueType { 35 public: 36 /// Create a type from a code completion result. 37 static llvm::Optional<OpaqueType> 38 fromCompletionResult(ASTContext &Ctx, const CodeCompletionResult &R); 39 /// Construct an instance from a clang::QualType. This is usually a 40 /// PreferredType from a clang's completion context. 41 static llvm::Optional<OpaqueType> fromType(ASTContext &Ctx, QualType Type); 42 43 /// Get the raw byte representation of the type. You can only rely on the 44 /// types being equal iff their raw representation is the same. The particular 45 /// details of the used encoding might change over time and one should not 46 /// rely on it. raw()47 llvm::StringRef raw() const { return Data; } 48 49 friend bool operator==(const OpaqueType &L, const OpaqueType &R) { 50 return L.Data == R.Data; 51 } 52 friend bool operator!=(const OpaqueType &L, const OpaqueType &R) { 53 return !(L == R); 54 } 55 56 private: 57 static llvm::Optional<OpaqueType> encode(ASTContext &Ctx, QualType Type); 58 explicit OpaqueType(std::string Data); 59 60 std::string Data; 61 }; 62 } // namespace clangd 63 } // namespace clang 64 #endif 65