contrib/llvm-project/lldb/include/lldb/Symbol/CompilerDecl.h

   1 //===-- CompilerDecl.h ------------------------------------------*- 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
   9 #ifndef liblldb_CompilerDecl_h_
  10 #define liblldb_CompilerDecl_h_
  11
  12 #include "lldb/Symbol/CompilerType.h"
  13 #include "lldb/Utility/ConstString.h"
  14 #include "lldb/lldb-private.h"
  15
  16 namespace lldb_private {
  17
  18 /// Represents a generic declaration such as a function declaration.
  19 ///
  20 /// This class serves as an abstraction for a declaration inside one of the
  21 /// TypeSystems implemented by the language plugins. It does not have any actual
  22 /// logic in it but only stores an opaque pointer and a pointer to the
  23 /// TypeSystem that gives meaning to this opaque pointer. All methods of this
  24 /// class should call their respective method in the TypeSystem interface and
  25 /// pass the opaque pointer along.
  26 ///
  27 /// \see lldb_private::TypeSystem
  28 class CompilerDecl {
  29 public:
  30   // Constructors and Destructors
  31   CompilerDecl() = default;
  32
  33   /// Creates a CompilerDecl with the given TypeSystem and opaque pointer.
  34   ///
  35   /// This constructor should only be called from the respective TypeSystem
  36   /// implementation.
  37   CompilerDecl(TypeSystem *type_system, void *decl)
  38       : m_type_system(type_system), m_opaque_decl(decl) {}
  39
  40   // Tests
  41
  42   explicit operator bool() const { return IsValid(); }
  43
  44   bool operator<(const CompilerDecl &rhs) const {
  45     if (m_type_system == rhs.m_type_system)
  46       return m_opaque_decl < rhs.m_opaque_decl;
  47     return m_type_system < rhs.m_type_system;
  48   }
  49
  50   bool IsValid() const {
  51     return m_type_system != nullptr && m_opaque_decl != nullptr;
  52   }
  53
  54   // Accessors
  55
  56   TypeSystem *GetTypeSystem() const { return m_type_system; }
  57
  58   void *GetOpaqueDecl() const { return m_opaque_decl; }
  59
  60   void SetDecl(TypeSystem *type_system, void *decl) {
  61     m_type_system = type_system;
  62     m_opaque_decl = decl;
  63   }
  64
  65   void Clear() {
  66     m_type_system = nullptr;
  67     m_opaque_decl = nullptr;
  68   }
  69
  70   ConstString GetName() const;
  71
  72   ConstString GetMangledName() const;
  73
  74   CompilerDeclContext GetDeclContext() const;
  75
  76   // If this decl represents a function, return the return type
  77   CompilerType GetFunctionReturnType() const;
  78
  79   // If this decl represents a function, return the number of arguments for the
  80   // function
  81   size_t GetNumFunctionArguments() const;
  82
  83   // If this decl represents a function, return the argument type given a zero
  84   // based argument index
  85   CompilerType GetFunctionArgumentType(size_t arg_idx) const;
  86
  87 private:
  88   TypeSystem *m_type_system = nullptr;
  89   void *m_opaque_decl = nullptr;
  90 };
  91
  92 bool operator==(const CompilerDecl &lhs, const CompilerDecl &rhs);
  93 bool operator!=(const CompilerDecl &lhs, const CompilerDecl &rhs);
  94
  95 } // namespace lldb_private
  96
  97 #endif // #ifndef liblldb_CompilerDecl_h_