Skip to content

[lldb][NFC] Assert ASTNodeUPs and pass ASTNodes by reference in DIL #173240

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
kuilpd wants to merge 1 commit into
base: main
Choose a base branch
from
Open

[lldb][NFC] Assert ASTNodeUPs and pass ASTNodes by reference in DIL #173240

kuilpd wants to merge 1 commit into from
+143 −138

Conversation

@kuilpd
Copy link
Contributor

@kuilpd kuilpd commented Dec 22, 2025

  1. Every ASTNodeUP is asserted before being used in creating another ASTNodeUP
  2. Removed returning nullptr in ParseIntegerLiteral and ParseFloatingPointLiteral to avoid confusion
  3. All ASTNodes are now passed by reference instead of pointer

@kuilpd kuilpd requested a review from Michael137 December 22, 2025 11:00
@kuilpd kuilpd requested a review from JDevlieghere as a code owner December 22, 2025 11:00
@kuilpd kuilpd added the lldb label Dec 22, 2025
@llvmbot
Copy link
Member

llvmbot commented Dec 22, 2025

@llvm/pr-subscribers-lldb

Author: Ilia Kuklin (kuilpd)

Changes
  1. Every ASTNodeUP is asserted before being used in creating another ASTNodeUP
  2. Removed returning nullptr in ParseIntegerLiteral and ParseFloatingPointLiteral to avoid confusion
  3. All ASTNodes are now passed by reference instead of pointer

Patch is 37.62 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/173240.diff

6 Files Affected:

  • (modified) lldb/include/lldb/ValueObject/DILAST.h (+37-37)
  • (modified) lldb/include/lldb/ValueObject/DILEval.h (+12-12)
  • (modified) lldb/source/Target/StackFrame.cpp (+1-1)
  • (modified) lldb/source/ValueObject/DILAST.cpp (+9-9)
  • (modified) lldb/source/ValueObject/DILEval.cpp (+74-74)
  • (modified) lldb/source/ValueObject/DILParser.cpp (+10-5)
diff --git a/lldb/include/lldb/ValueObject/DILAST.h b/lldb/include/lldb/ValueObject/DILAST.h
index bf7d83ef3e3e1..247ea392727ff 100644
--- a/lldb/include/lldb/ValueObject/DILAST.h
+++ b/lldb/include/lldb/ValueObject/DILAST.h
@@ -83,8 +83,8 @@ class ErrorNode : public ASTNode {
   ErrorNode() : ASTNode(0, NodeKind::eErrorNode) {}
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eErrorNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eErrorNode;
   }
 };
 
@@ -97,8 +97,8 @@ class IdentifierNode : public ASTNode {
 
   std::string GetName() const { return m_name; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eIdentifierNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eIdentifierNode;
   }
 
 private:
@@ -114,12 +114,12 @@ class MemberOfNode : public ASTNode {
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
-  ASTNode *GetBase() const { return m_base.get(); }
+  ASTNode &GetBase() const { return *m_base; }
   bool GetIsArrow() const { return m_is_arrow; }
   llvm::StringRef GetFieldName() const { return llvm::StringRef(m_field_name); }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eMemberOfNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eMemberOfNode;
   }
 
 private:
@@ -137,10 +137,10 @@ class UnaryOpNode : public ASTNode {
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   UnaryOpKind GetKind() const { return m_kind; }
-  ASTNode *GetOperand() const { return m_operand.get(); }
+  ASTNode &GetOperand() const { return *m_operand; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eUnaryOpNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eUnaryOpNode;
   }
 
 private:
@@ -156,11 +156,11 @@ class ArraySubscriptNode : public ASTNode {
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
-  ASTNode *GetBase() const { return m_base.get(); }
-  ASTNode *GetIndex() const { return m_index.get(); }
+  ASTNode &GetBase() const { return *m_base; }
+  ASTNode &GetIndex() const { return *m_index; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eArraySubscriptNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eArraySubscriptNode;
   }
 
 private:
@@ -178,12 +178,12 @@ class BitFieldExtractionNode : public ASTNode {
 
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
-  ASTNode *GetBase() const { return m_base.get(); }
-  ASTNode *GetFirstIndex() const { return m_first_index.get(); }
-  ASTNode *GetLastIndex() const { return m_last_index.get(); }
+  ASTNode &GetBase() const { return *m_base; }
+  ASTNode &GetFirstIndex() const { return *m_first_index; }
+  ASTNode &GetLastIndex() const { return *m_last_index; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eBitExtractionNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eBitExtractionNode;
   }
 
 private:
@@ -209,8 +209,8 @@ class IntegerLiteralNode : public ASTNode {
   bool IsUnsigned() const { return m_is_unsigned; }
   IntegerTypeSuffix GetTypeSuffix() const { return m_type; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eIntegerLiteralNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eIntegerLiteralNode;
   }
 
 private:
@@ -230,8 +230,8 @@ class FloatLiteralNode : public ASTNode {
 
   const llvm::APFloat &GetValue() const { return m_value; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eFloatLiteralNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eFloatLiteralNode;
   }
 
 private:
@@ -247,8 +247,8 @@ class BooleanLiteralNode : public ASTNode {
 
   bool GetValue() const & { return m_value; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eBooleanLiteralNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eBooleanLiteralNode;
   }
 
 private:
@@ -265,11 +265,11 @@ class CastNode : public ASTNode {
   llvm::Expected<lldb::ValueObjectSP> Accept(Visitor *v) const override;
 
   CompilerType GetType() const { return m_type; }
-  ASTNode *GetOperand() const { return m_operand.get(); }
+  ASTNode &GetOperand() const { return *m_operand; }
   CastKind GetCastKind() const { return m_cast_kind; }
 
-  static bool classof(const ASTNode *node) {
-    return node->GetKind() == NodeKind::eCastNode;
+  static bool classof(const ASTNode &node) {
+    return node.GetKind() == NodeKind::eCastNode;
   }
 
 private:
@@ -286,22 +286,22 @@ class Visitor {
 public:
   virtual ~Visitor() = default;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const IdentifierNode *node) = 0;
+  Visit(const IdentifierNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const MemberOfNode *node) = 0;
+  Visit(const MemberOfNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const UnaryOpNode *node) = 0;
+  Visit(const UnaryOpNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const ArraySubscriptNode *node) = 0;
+  Visit(const ArraySubscriptNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const BitFieldExtractionNode *node) = 0;
+  Visit(const BitFieldExtractionNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const IntegerLiteralNode *node) = 0;
+  Visit(const IntegerLiteralNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const FloatLiteralNode *node) = 0;
+  Visit(const FloatLiteralNode &node) = 0;
   virtual llvm::Expected<lldb::ValueObjectSP>
-  Visit(const BooleanLiteralNode *node) = 0;
-  virtual llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode *node) = 0;
+  Visit(const BooleanLiteralNode &node) = 0;
+  virtual llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode &node) = 0;
 };
 
 } // namespace lldb_private::dil
diff --git a/lldb/include/lldb/ValueObject/DILEval.h b/lldb/include/lldb/ValueObject/DILEval.h
index fc4b8e1817e66..d73e1182ab01b 100644
--- a/lldb/include/lldb/ValueObject/DILEval.h
+++ b/lldb/include/lldb/ValueObject/DILEval.h
@@ -45,29 +45,29 @@ class Interpreter : Visitor {
 
   /// Evaluate an ASTNode.
   /// \returns A non-null lldb::ValueObjectSP or an Error.
-  llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode *node);
+  llvm::Expected<lldb::ValueObjectSP> Evaluate(const ASTNode &node);
 
 private:
   /// Evaluate an ASTNode. If the result is a reference, it is also
   /// dereferenced using ValueObject::Dereference.
   /// \returns A non-null lldb::ValueObjectSP or an Error.
   llvm::Expected<lldb::ValueObjectSP>
-  EvaluateAndDereference(const ASTNode *node);
+  EvaluateAndDereference(const ASTNode &node);
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const IdentifierNode *node) override;
-  llvm::Expected<lldb::ValueObjectSP> Visit(const MemberOfNode *node) override;
-  llvm::Expected<lldb::ValueObjectSP> Visit(const UnaryOpNode *node) override;
+  Visit(const IdentifierNode &node) override;
+  llvm::Expected<lldb::ValueObjectSP> Visit(const MemberOfNode &node) override;
+  llvm::Expected<lldb::ValueObjectSP> Visit(const UnaryOpNode &node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const ArraySubscriptNode *node) override;
+  Visit(const ArraySubscriptNode &node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const BitFieldExtractionNode *node) override;
+  Visit(const BitFieldExtractionNode &node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const IntegerLiteralNode *node) override;
+  Visit(const IntegerLiteralNode &node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const FloatLiteralNode *node) override;
+  Visit(const FloatLiteralNode &node) override;
   llvm::Expected<lldb::ValueObjectSP>
-  Visit(const BooleanLiteralNode *node) override;
-  llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode *node) override;
+  Visit(const BooleanLiteralNode &node) override;
+  llvm::Expected<lldb::ValueObjectSP> Visit(const CastNode &node) override;
 
   /// Perform usual unary conversions on a value. At the moment this
   /// includes array-to-pointer and integral promotion for eligible types.
@@ -76,7 +76,7 @@ class Interpreter : Visitor {
   llvm::Expected<CompilerType>
   PickIntegerType(lldb::TypeSystemSP type_system,
                   std::shared_ptr<ExecutionContextScope> ctx,
-                  const IntegerLiteralNode *literal);
+                  const IntegerLiteralNode &literal);
 
   // Used by the interpreter to create objects, perform casts, etc.
   lldb::TargetSP m_target;
diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp
index 3bbb851b88007..92d0099be972a 100644
--- a/lldb/source/Target/StackFrame.cpp
+++ b/lldb/source/Target/StackFrame.cpp
@@ -569,7 +569,7 @@ ValueObjectSP StackFrame::DILGetValueForVariableExpressionPath(
                                use_dynamic, !no_synth_child, !no_fragile_ivar,
                                check_ptr_vs_member);
 
-  auto valobj_or_error = interpreter.Evaluate((*tree_or_error).get());
+  auto valobj_or_error = interpreter.Evaluate(**tree_or_error);
   if (!valobj_or_error) {
     error = Status::FromError(valobj_or_error.takeError());
     return ValueObjectConstResult::Create(nullptr, std::move(error));
diff --git a/lldb/source/ValueObject/DILAST.cpp b/lldb/source/ValueObject/DILAST.cpp
index 0b9e1f4d48ac8..d8a714d33712d 100644
--- a/lldb/source/ValueObject/DILAST.cpp
+++ b/lldb/source/ValueObject/DILAST.cpp
@@ -16,43 +16,43 @@ llvm::Expected<lldb::ValueObjectSP> ErrorNode::Accept(Visitor *v) const {
 }
 
 llvm::Expected<lldb::ValueObjectSP> IdentifierNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP> MemberOfNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP> UnaryOpNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP>
 ArraySubscriptNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP>
 BitFieldExtractionNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP>
 IntegerLiteralNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP> FloatLiteralNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP>
 BooleanLiteralNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 llvm::Expected<lldb::ValueObjectSP> CastNode::Accept(Visitor *v) const {
-  return v->Visit(this);
+  return v->Visit(*this);
 }
 
 } // namespace lldb_private::dil
diff --git a/lldb/source/ValueObject/DILEval.cpp b/lldb/source/ValueObject/DILEval.cpp
index 53413aeb35ccd..445c949b581b6 100644
--- a/lldb/source/ValueObject/DILEval.cpp
+++ b/lldb/source/ValueObject/DILEval.cpp
@@ -239,20 +239,20 @@ Interpreter::Interpreter(lldb::TargetSP target, llvm::StringRef expr,
       m_fragile_ivar(fragile_ivar), m_check_ptr_vs_member(check_ptr_vs_member) {
 }
 
-llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode *node) {
+llvm::Expected<lldb::ValueObjectSP> Interpreter::Evaluate(const ASTNode &node) {
   // Evaluate an AST.
-  auto value_or_error = node->Accept(this);
+  auto value_or_error = node.Accept(this);
   // Convert SP with a nullptr to an error.
   if (value_or_error && !*value_or_error)
     return llvm::make_error<DILDiagnosticError>(m_expr, "invalid value object",
-                                                node->GetLocation());
+                                                node.GetLocation());
   // Return the computed value-or-error. The caller is responsible for
   // checking if an error occured during the evaluation.
   return value_or_error;
 }
 
 llvm::Expected<lldb::ValueObjectSP>
-Interpreter::EvaluateAndDereference(const ASTNode *node) {
+Interpreter::EvaluateAndDereference(const ASTNode &node) {
   auto valobj_or_err = Evaluate(node);
   if (!valobj_or_err)
     return valobj_or_err;
@@ -268,35 +268,35 @@ Interpreter::EvaluateAndDereference(const ASTNode *node) {
 }
 
 llvm::Expected<lldb::ValueObjectSP>
-Interpreter::Visit(const IdentifierNode *node) {
+Interpreter::Visit(const IdentifierNode &node) {
   lldb::DynamicValueType use_dynamic = m_use_dynamic;
 
   lldb::ValueObjectSP identifier =
-      LookupIdentifier(node->GetName(), m_exe_ctx_scope, use_dynamic);
+      LookupIdentifier(node.GetName(), m_exe_ctx_scope, use_dynamic);
 
   if (!identifier)
-    identifier = LookupGlobalIdentifier(node->GetName(), m_exe_ctx_scope,
+    identifier = LookupGlobalIdentifier(node.GetName(), m_exe_ctx_scope,
                                         m_target, use_dynamic);
   if (!identifier) {
     std::string errMsg =
-        llvm::formatv("use of undeclared identifier '{0}'", node->GetName());
+        llvm::formatv("use of undeclared identifier '{0}'", node.GetName());
     return llvm::make_error<DILDiagnosticError>(
-        m_expr, errMsg, node->GetLocation(), node->GetName().size());
+        m_expr, errMsg, node.GetLocation(), node.GetName().size());
   }
 
   return identifier;
 }
 
 llvm::Expected<lldb::ValueObjectSP>
-Interpreter::Visit(const UnaryOpNode *node) {
+Interpreter::Visit(const UnaryOpNode &node) {
   Status error;
-  auto op_or_err = Evaluate(node->GetOperand());
+  auto op_or_err = Evaluate(node.GetOperand());
   if (!op_or_err)
     return op_or_err;
 
   lldb::ValueObjectSP operand = *op_or_err;
 
-  switch (node->GetKind()) {
+  switch (node.GetKind()) {
   case UnaryOpKind::Deref: {
     lldb::ValueObjectSP dynamic_op = operand->GetDynamicValue(m_use_dynamic);
     if (dynamic_op)
@@ -311,7 +311,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
     }
     if (error.Fail())
       return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
-                                                  node->GetLocation());
+                                                  node.GetLocation());
 
     return child_sp;
   }
@@ -320,7 +320,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
     lldb::ValueObjectSP value = operand->AddressOf(error);
     if (error.Fail())
       return llvm::make_error<DILDiagnosticError>(m_expr, error.AsCString(),
-                                                  node->GetLocation());
+                                                  node.GetLocation());
 
     return value;
   }
@@ -331,7 +331,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
         return error.ToError();
     }
     llvm::Expected<lldb::ValueObjectSP> conv_op =
-        UnaryConversion(operand, node->GetOperand()->GetLocation());
+        UnaryConversion(operand, node.GetOperand().GetLocation());
     if (!conv_op)
       return conv_op;
     operand = *conv_op;
@@ -341,7 +341,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
           llvm::formatv("invalid argument type '{0}' to unary expression",
                         operand_type.GetTypeName());
       return llvm::make_error<DILDiagnosticError>(m_expr, errMsg,
-                                                  node->GetLocation());
+                                                  node.GetLocation());
     }
     Scalar scalar;
     bool resolved = operand->ResolveValue(scalar);
@@ -361,7 +361,7 @@ Interpreter::Visit(const UnaryOpNode *node) {
         return error.ToError();
     }
     llvm::Expected<lldb::ValueObjectSP> conv_op =
-        UnaryConversion(operand, node->GetOperand()->GetLocation());
+        UnaryConversion(operand, node.GetOperand().GetLocation());
     if (!conv_op)
       return conv_op;
     operand = *conv_op;
@@ -373,25 +373,25 @@ Interpreter::Visit(const UnaryOpNode *node) {
           llvm::formatv("invalid argument type '{0}' to unary expression",
                         operand_type.GetTypeName());
       return llvm::make_error<DILDiagnosticError>(m_expr, errMsg,
-                                                  node->GetLocation());
+                                                  node.GetLocation());
     }
     return operand;
   }
   }
   return llvm::make_error<DILDiagnosticError>(m_expr, "invalid unary operation",
-                                              node->GetLocation());
+                                              node.GetLocation());
 }
 
 llvm::Expected<lldb::ValueObjectSP>
-Interpreter::Visit(const MemberOfNode *node) {
-  auto base_or_err = Evaluate(node->GetBase());
+Interpreter::Visit(const MemberOfNode &node) {
+  auto base_or_err = Evaluate(node.GetBase());
   if (!base_or_err)
     return base_or_err;
-  bool expr_is_ptr = node->GetIsArrow();
+  bool expr_is_ptr = node.GetIsArrow();
   lldb::ValueObjectSP base = *base_or_err;
 
   // Perform some basic type & correctness checking.
-  if (node->GetIsArrow()) {
+  if (node.GetIsArrow()) {
     if (!m_fragile_ivar) {
       // Make sure we aren't trying to deref an objective
       // C ivar if this is not allowed
@@ -418,14 +418,14 @@ Interpreter::Visit(const MemberOfNode *node) {
         std::string errMsg = llvm::formatv(
             "Failed to dereference synthetic value: {0}", deref_error);
         return llvm::make_error<DILDiagnosticError>(
-            m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
+            m_expr, errMsg, node.GetLocation(), node.GetFieldName().size());
       }
 
       // Some synthetic plug-ins fail to set the error in Dereference
       if (!base) {
         std::string errMsg = "Failed to dereference synthetic value";
         return llvm::make_error<DILDiagnosticError>(
-            m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
+            m_expr, errMsg, node.GetLocation(), node.GetFieldName().size());
       }
       expr_is_ptr = false;
     }
@@ -441,33 +441,33 @@ Interpreter::Visit(const MemberOfNode *node) {
                           "did you mean to use '->'?",
                           base->GetCompilerType().TypeDescription());
         return llvm::make_error<DILDiagnosticError>(
-            m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
+            m_expr, errMsg, node.GetLocation(), node.GetFieldName().size());
       } else {
         std::string errMsg =
             llvm::formatv("member reference type {0} is not a pointer; "
                           "did you mean to use '.'?",
                           base->GetCompilerType().TypeDescription());
         return llvm::make_error<DILDiagnosticError>(
-            m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
+            m_expr, errMsg, node.GetLocation(), node.GetFieldName().size());
       }
     }
   }
 
   lldb::ValueObjectSP field_obj =
-      base->GetChildMemberWithName(node->GetFieldName());
+      base->GetChildMemberWithName(node.GetFieldName());
   if (!field_obj) {
     if (m_use_synthetic) {
       field_obj = base->GetSyntheticValue();
       if (field_obj)
-        field_obj = field_obj->GetChildMemberWithName(node->GetFieldName());
+        field_obj = field_obj->GetChildMemberWithName(node.GetFieldName());
     }
 
     if (!m_use_synthetic || !field_obj) {
       std::string errMsg = llvm::formatv(
-          "\"{0}\" is not a member of \"({1}) {2}\"", node->GetFieldName(),
+          "\"{0}\" is not a member of \"({1}) {2}\"", node.GetFieldName(),
           base->GetTypeName().AsCString("<invalid type>"), base->GetName());
       return llvm::make_error<DILDiagnosticError>(
-          m_expr, errMsg, node->GetLocation(), node->GetFieldName().size());
+          m_expr, errMsg, node.GetLocation(), node.GetFieldName().size());
     }
   }
 
@@ -482,32 +482,32 @@ Interpreter::Vis...
[truncated]

@kuilpd
Copy link
Contributor Author

kuilpd commented Dec 22, 2025

@Michael137
I implemented your suggestion of asserting ASTNodeUPs and returning them by reference from functions like GetIndex(). But I also changed ASTNodes everywhere in DIL to be passed by reference instead of a pointer, so that we don't have to worry about nullptr there as well. Does it make sense or is it an overkill?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@Michael137 Michael137 Awaiting requested review from Michael137

@JDevlieghere JDevlieghere Awaiting requested review from JDevlieghere JDevlieghere is a code owner

Assignees

No one assigned

Labels

lldb

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

2 participants

@kuilpd @llvmbot