Merge pull request #35 from access-softek/dil-local-vars-2

Update code to made upstream local variables PR.

Author: cmtice

lldb/include/lldb/ValueObject/DILAST.h

@@ -18,6 +18,8 @@
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
@@ -280,12 +282,11 @@ class StringLiteralNode : public ASTNode {
 class IdentifierNode : public ASTNode {
 public:
   IdentifierNode(uint32_t location, std::string name,
-                 lldb::DynamicValueType use_dynamic,
                  std::unique_ptr<IdentifierInfo> identifier, bool is_rvalue,
                  bool is_context_var)
       : ASTNode(location, NodeKind::eIdentifierNode), m_is_rvalue(is_rvalue),
         m_is_context_var(is_context_var), m_name(std::move(name)),
-        m_identifier(std::move(identifier)), m_use_dynamic(use_dynamic) {}
+        m_identifier(std::move(identifier)) {}
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
   bool is_rvalue() const override { return m_is_rvalue; }
@@ -297,7 +298,6 @@ class IdentifierNode : public ASTNode {
     return m_identifier->GetValue().get();
   }
 
-  lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
   std::string GetName() const { return m_name; }
   const IdentifierInfo &info() const { return *m_identifier; }
 
@@ -310,7 +310,6 @@ class IdentifierNode : public ASTNode {
   bool m_is_context_var;
   std::string m_name;
   std::unique_ptr<IdentifierInfo> m_identifier;
-  lldb::DynamicValueType m_use_dynamic;
 };
 
 class SizeOfNode : public ASTNode {

lldb/include/lldb/ValueObject/DILEval.h

@@ -11,6 +11,8 @@
 
 #include "lldb/ValueObject/DILAST.h"
 #include "lldb/ValueObject/DILParser.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 #include <memory>
 #include <vector>
 
@@ -54,15 +56,14 @@ class Interpreter : Visitor {
               lldb::DynamicValueType use_dynamic,
               std::shared_ptr<StackFrame> frame_sp);
 
-  llvm::Expected<lldb::ValueObjectSP> DILEval(const ASTNode *tree,
-                                              lldb::TargetSP target_sp);
+  llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode *tree);
 
   void SetContextVars(
       std::unordered_map<std::string, lldb::ValueObjectSP> context_vars);
 
  protected:
-   llvm::Expected<lldb::ValueObjectSP>
-   DILEvalNode(const ASTNode *node, FlowAnalysis *flow = nullptr);
+   llvm::Expected<lldb::ValueObjectSP> EvalNode(const ASTNode *node,
+                                                FlowAnalysis *flow = nullptr);
 
    lldb::ValueObjectSP EvaluateMemberOf(lldb::ValueObjectSP value,
                                         const std::vector<uint32_t> &path,

lldb/include/lldb/ValueObject/DILParser.h

@@ -10,13 +10,16 @@
 #define LLDB_VALUEOBJECT_DILPARSER_H
 
 #include "lldb/Target/ExecutionContextScope.h"
+#include "lldb/Utility/DiagnosticsRendering.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/ValueObject/DILAST.h"
 #include "lldb/ValueObject/DILLexer.h"
 #include "lldb/ValueObject/DILLiteralParsers.h"
+#include "llvm/Support/Error.h"
 #include <memory>
 #include <optional>
 #include <string>
+#include <system_error>
 #include <tuple>
 #include <vector>
 
@@ -69,8 +72,30 @@ enum class ErrorCode : unsigned char {
   kUnknown,
 };
 
-std::string FormatDiagnostics(llvm::StringRef input_expr,
-                              const std::string &message, uint32_t loc);
+// The following is modeled on class OptionParseError.
+class DILDiagnosticError
+    : public llvm::ErrorInfo<DILDiagnosticError, DiagnosticError> {
+  DiagnosticDetail m_detail;
+
+public:
+  using llvm::ErrorInfo<DILDiagnosticError, DiagnosticError>::ErrorInfo;
+  DILDiagnosticError(DiagnosticDetail detail)
+      : ErrorInfo(make_error_code(std::errc::invalid_argument)),
+        m_detail(std::move(detail)) {}
+
+  DILDiagnosticError(llvm::StringRef expr, const std::string &message,
+                     uint32_t loc, uint16_t err_len);
+
+  std::unique_ptr<CloneableError> Clone() const override {
+    return std::make_unique<DILDiagnosticError>(m_detail);
+  }
+
+  llvm::ArrayRef<DiagnosticDetail> GetDetails() const override {
+    return {m_detail};
+  }
+
+  std::string message() const override { return m_detail.rendered; }
+};
 
 Status SetUbStatus(ErrorCode code);
 
@@ -170,9 +195,9 @@ class DILParser {
                       std::shared_ptr<StackFrame> frame_sp,
                       lldb::DynamicValueType use_dynamic, bool use_synthetic,
                       bool fragile_ivar, bool check_ptr_vs_member,
-                      Status &error);
+                      llvm::Error &error);
 
-   llvm::Expected<ASTNodeUP> Run();
+   ASTNodeUP Run();
 
    ASTNodeUP ParseExpression();
    ASTNodeUP ParseAssignmentExpression();
@@ -227,9 +252,7 @@ class DILParser {
                                     bool is_src_literal_zero = false);
    ASTNodeUP InsertImplicitConversion(ASTNodeUP expr, CompilerType type);
 
-   void BailOut(ErrorCode error_code, const std::string &error, uint32_t loc);
-
-   void BailOut(Status error);
+   void BailOut(const std::string &error, uint32_t loc, uint16_t err_len);
 
    void Expect(Token::Kind kind);
 
@@ -297,7 +320,8 @@ class DILParser {
    }
 
   void TentativeParsingRollback(uint32_t saved_idx) {
-    m_error.Clear();
+    if (m_error)
+      llvm::consumeError(std::move(m_error));
     m_dil_lexer.ResetTokenIdx(saved_idx);
   }
 
@@ -312,7 +336,7 @@ class DILParser {
 
   DILLexer m_dil_lexer;
   // Holds an error if it occures during parsing.
-  Status &m_error;
+  llvm::Error &m_error;
 
   bool m_allow_side_effects = true;
 

lldb/source/Target/StackFrame.cpp

@@ -558,7 +558,7 @@ ValueObjectSP StackFrame::DILGetValueForVariableExpressionPath(
   dil::Interpreter interpreter(target, var_expr, use_dynamic,
                                shared_from_this());
 
-  auto valobj_or_error = interpreter.DILEval((*tree_or_error).get(), target);
+  auto valobj_or_error = interpreter.Evaluate((*tree_or_error).get());
   if (!valobj_or_error) {
     error = Status::FromError(valobj_or_error.takeError());
     return ValueObjectSP();