Store index as int64_t; refactor code.

Author: kuilpd

lldb/include/lldb/ValueObject/DILAST.h

@@ -112,22 +112,22 @@ class UnaryOpNode : public ASTNode {
 
 class ArraySubscriptNode : public ASTNode {
 public:
-  ArraySubscriptNode(uint32_t location, ASTNodeUP base, llvm::APInt index)
+  ArraySubscriptNode(uint32_t location, ASTNodeUP base, int64_t index)
       : ASTNode(location, NodeKind::eArraySubscriptNode),
-        m_base(std::move(base)), m_index(std::move(index)) {}
+        m_base(std::move(base)), m_index(index) {}
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   ASTNode *GetBase() const { return m_base.get(); }
-  const llvm::APInt *GetIndex() const { return &m_index; }
+  int64_t GetIndex() const { return m_index; }
 
   static bool classof(const ASTNode *node) {
     return node->GetKind() == NodeKind::eArraySubscriptNode;
   }
 
 private:
   ASTNodeUP m_base;
-  llvm::APInt m_index;
+  int64_t m_index;
 };
 
 /// This class contains one Visit method for each specialized type of

lldb/include/lldb/ValueObject/DILParser.h

@@ -91,7 +91,7 @@ class DILParser {
 
   std::string ParseIdExpression();
   std::string ParseUnqualifiedId();
-  std::optional<llvm::APInt> ParseIntegerConstant();
+  std::optional<int64_t> ParseIntegerConstant();
 
   void BailOut(const std::string &error, uint32_t loc, uint16_t err_len);
 

lldb/source/ValueObject/DILEval.cpp

@@ -275,47 +275,29 @@ Interpreter::Visit(const UnaryOpNode *node) {
 llvm::Expected<lldb::ValueObjectSP>
 Interpreter::Visit(const ArraySubscriptNode *node) {
   auto lhs_or_err = Evaluate(node->GetBase());
-  if (!lhs_or_err) {
+  if (!lhs_or_err)
     return lhs_or_err;
-  }
   lldb::ValueObjectSP base = *lhs_or_err;
-  const llvm::APInt *index = node->GetIndex();
-
-  Status error;
-  if (base->GetCompilerType().IsReferenceType()) {
-    base = base->Dereference(error);
-    if (error.Fail())
-      return error.ToError();
-  }
 
   // Check to see if 'base' has a synthetic value; if so, try using that.
-  uint64_t child_idx = index->getZExtValue();
-  if (base->HasSyntheticValue()) {
-    lldb::ValueObjectSP synthetic = base->GetSyntheticValue();
-    if (synthetic && synthetic != base) {
-      uint32_t num_children = synthetic->GetNumChildrenIgnoringErrors();
-      // Verify that the 'index' is not out-of-range for the declared type.
-      if (child_idx >= num_children) {
-        auto message = llvm::formatv(
-            "array index {0} is not valid for \"({1}) {2}\"", child_idx,
-            base->GetTypeName().AsCString("<invalid type>"),
-            base->GetName().AsCString());
-        return llvm::make_error<DILDiagnosticError>(m_expr, message,
-                                                    node->GetLocation());
-      }
-
-      if (static_cast<uint32_t>(child_idx) <
-          synthetic->GetNumChildrenIgnoringErrors()) {
-        lldb::ValueObjectSP child_valobj_sp =
-            synthetic->GetChildAtIndex(child_idx);
-        if (child_valobj_sp) {
-          return child_valobj_sp;
-        }
-      }
+  uint64_t child_idx = node->GetIndex();
+  if (lldb::ValueObjectSP synthetic = base->GetSyntheticValue()) {
+    uint32_t num_children = synthetic->GetNumChildrenIgnoringErrors();
+    // Verify that the 'index' is not out-of-range for the declared type.
+    if (child_idx >= num_children) {
+      std::string message = llvm::formatv(
+          "array index {0} is not valid for \"({1}) {2}\"", child_idx,
+          base->GetTypeName().AsCString("<invalid type>"),
+          base->GetName().AsCString());
+      return llvm::make_error<DILDiagnosticError>(m_expr, message,
+                                                  node->GetLocation());
     }
+    if (lldb::ValueObjectSP child_valobj_sp =
+            synthetic->GetChildAtIndex(child_idx))
+      return child_valobj_sp;
   }
 
-  auto base_type = base->GetCompilerType();
+  auto base_type = base->GetCompilerType().GetNonReferenceType();
   if (!base_type.IsPointerType() && !base_type.IsArrayType())
     return llvm::make_error<DILDiagnosticError>(
         m_expr, "subscripted value is not an array or pointer",
@@ -326,12 +308,11 @@ Interpreter::Visit(const ArraySubscriptNode *node) {
         node->GetLocation());
 
   if (base_type.IsArrayType()) {
-    uint32_t num_children = base->GetNumChildrenIgnoringErrors();
-    if (child_idx < num_children)
-      return base->GetChildAtIndex(child_idx);
+    if (lldb::ValueObjectSP child_valobj_sp = base->GetChildAtIndex(child_idx))
+      return child_valobj_sp;
   }
 
-  int64_t signed_child_idx = index->getSExtValue();
+  int64_t signed_child_idx = node->GetIndex();
   return base->GetSyntheticArrayMember(signed_child_idx, true);
 }
 

lldb/source/ValueObject/DILLexer.cpp

@@ -101,10 +101,8 @@ llvm::Expected<Token> DILLexer::Lex(llvm::StringRef expr,
 
   uint32_t position = cur_pos - expr.begin();
   std::optional<llvm::StringRef> maybe_number = IsNumber(expr, remainder);
-  if (maybe_number) {
-    std::string number = (*maybe_number).str();
-    return Token(Token::numeric_constant, number, position);
-  }
+  if (maybe_number)
+    return Token(Token::numeric_constant, maybe_number->str(), position);
   std::optional<llvm::StringRef> maybe_word = IsWord(expr, remainder);
   if (maybe_word)
     return Token(Token::identifier, maybe_word->str(), position);

lldb/source/ValueObject/DILParser.cpp

@@ -128,7 +128,7 @@ ASTNodeUP DILParser::ParsePostfixExpression() {
     switch (token.GetKind()) {
     case Token::l_square: {
       m_dil_lexer.Advance();
-      auto rhs = ParseIntegerConstant();
+      std::optional<int64_t> rhs = ParseIntegerConstant();
       if (!rhs) {
         BailOut(
             llvm::formatv("failed to parse integer constant: {0}", CurToken()),
@@ -320,11 +320,11 @@ void DILParser::BailOut(const std::string &error, uint32_t loc,
 //  integer_literal:
 //    ? Integer constant ?
 //
-std::optional<llvm::APInt> DILParser::ParseIntegerConstant() {
+std::optional<int64_t> DILParser::ParseIntegerConstant() {
   auto spelling = CurToken().GetSpelling();
   llvm::StringRef spelling_ref = spelling;
-  llvm::APInt raw_value;
-  if (!spelling_ref.getAsInteger(0, raw_value)) {
+  int64_t raw_value;
+  if (!spelling_ref.getAsInteger<int64_t>(0, raw_value)) {
     m_dil_lexer.Advance();
     return raw_value;
   }

lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py

@@ -58,16 +58,21 @@ def test_dereference(self):
         # Test address-of of the subscripted value.
         self.expect_var_path("*(&int_arr[1])", value="2")
 
-        # Test synthetic value subscription
-        self.expect_var_path("vector[1]", value="2")
-
         # Test for negative index.
         self.expect(
             "frame var 'int_arr[-1]'",
             error=True,
             substrs=["unrecognized token"],
         )
 
+        # Test synthetic value subscription
+        self.expect_var_path("vector[1]", value="2")
+        self.expect(
+            "frame var 'vector[100]'",
+            error=True,
+            substrs=["array index 100 is not valid"],
+        )
+
         # Test for floating point index
         self.expect(
             "frame var 'int_arr[1.0]'",
@@ -76,6 +81,16 @@ def test_dereference(self):
         )
 
         # Base should be a "pointer to T" and index should be of an integral type.
+        self.expect(
+            "frame var 'idx_1[0]'",
+            error=True,
+            substrs=["subscripted value is not an array or pointer"],
+        )
+        self.expect(
+            "frame var 'idx_1_ref[0]'",
+            error=True,
+            substrs=["subscripted value is not an array or pointer"],
+        )
         self.expect(
             "frame var 'int_arr[int_ptr]'",
             error=True,
@@ -86,3 +101,10 @@ def test_dereference(self):
             error=True,
             substrs=["Unexpected token"],
         )
+
+        # Base should not be a pointer to void
+        self.expect(
+            "frame var 'p_void[0]'",
+            error=True,
+            substrs=["subscript of pointer to incomplete type 'void'"],
+        )

lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/main.cpp

@@ -4,6 +4,7 @@ int main(int argc, char **argv) {
   int int_arr[] = {1, 2, 3};
   int *int_ptr = int_arr;
   int(&int_arr_ref)[3] = int_arr;
+  void *p_void = (void *)int_arr;
 
   int idx_1 = 1;
   const int &idx_1_ref = idx_1;