Add SBValue::TypeIsReferenceType to SB API.

[sivachandra]

Is SBType::GetTypeClass not good enough?
That said, the aim of this change is not very clear to me. If SBType::GetTypeClass is sufficient, then having another way to figure whether a value is of a reference type is probably a bloat to the API.

Another, may be unrelated but could be relevant, point is whether you want this new method to see through typedefs.

[chaoren]

Whoops, sorry. I saw there was a TypeIsPointerType, but not one for references. Yeah, GetType().IsReferenceType() would be identical, so this is unnecessary. TypeIsPointerType seems pretty unnecessary now too.

[clayborg]

API was added that should never have made it into the SB API:

``

bool
SBValue::TypeIsPointerType ();

This led to others seeing this code and thinking it was OK. Now that the above function is in our API we can't remove it, but we should encourage the use of SBValue::GetType().XXX() from here on out.

include/lldb/API/SBValue.h

#endif
     lldb::SBFrame
     GetFrame();
     
     lldb::SBValue
     Dereference ();
 
     bool
     TypeIsPointerType ();
-    
+    bool
+    TypeIsReferenceType();
+
     lldb::SBType
     GetType();
     
     lldb::SBValue
     Persist ();
 
     bool
     GetDescription (lldb::SBStream &description);

include/lldb/Core/ValueObject.h

//        SetContext (ExecutionContextScope *exe_scope);
     virtual lldb::LanguageType
     GetObjectRuntimeLanguage();
 
     virtual uint32_t
     GetTypeInfo (ClangASTType *pointee_or_element_clang_type = NULL);
 
     virtual bool
     IsPointerType ();
-    
     virtual bool
+    IsReferenceType();
+
+    virtual bool
     IsArrayType ();
     
     virtual bool
     IsScalarType ();
 
     virtual bool
     IsPointerOrReferenceType ();
     

scripts/interface/SBValue.i

CreateValueFromData (const char* name,
     lldb::SBValue
     Dereference ();
 
     lldb::SBValue
     AddressOf();
     
     bool
     TypeIsPointerType ();
-    
+    bool
+    TypeIsReferenceType();
+
     lldb::SBTarget
     GetTarget();
 
     lldb::SBProcess
     GetProcess();
     
     lldb::SBThread
     GetThread();

source/API/SBValue.cpp

SBValue::TypeIsPointerType ()
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     if (log)
         log->Printf ("SBValue(%p)::TypeIsPointerType () => %i",
                      static_cast<void*>(value_sp.get()), is_ptr_type);
 
     return is_ptr_type;
 }
 
+bool
+SBValue::TypeIsReferenceType()
+{
+    bool is_ref_type = false;
+
+    ValueLocker locker;
+    lldb::ValueObjectSP value_sp(GetSP(locker));
+    if (value_sp)
+        is_ref_type = value_sp->IsReferenceType();
+
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (log)
+        log->Printf("SBValue(%p)::TypeIsReferenceType() => %i",
+                    static_cast<void*>(value_sp.get()), is_ref_type);
+
+    return is_ref_type;
+}
+
 void *
 SBValue::GetOpaqueType()
 {
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
         return value_sp->GetClangType().GetOpaqueQualType();
     return NULL;

source/Core/ValueObject.cpp

 
 bool
 ValueObject::IsPointerType ()
 {
     return GetClangType().IsPointerType();
 }
 
 bool
+ValueObject::IsReferenceType()
+{
+    return GetClangType().IsReferenceType();
+}
+
+bool
 ValueObject::IsArrayType ()
 {
     return GetClangType().IsArrayType (NULL, NULL, NULL);
 }
 
 bool
 ValueObject::IsScalarType ()
 {

test/python_api/value/Makefile

 LEVEL = ../../make
 
-C_SOURCES := main.c
+CXX_SOURCES := main.cpp
 
 include $(LEVEL)/Makefile.rules

test/python_api/value/TestValueAPI.py

def test_with_dwarf(self):
         self.setTearDownCleanup(dictionary=d)
         self.value_api(self.exe_name)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
-        # Find the line number to of function 'c'.
-        self.line = line_number('main.c', '// Break at this line')
+        self.line = line_number('main.cpp', '// Break at this line')
 
     def value_api(self, exe_name):
         """Exercise some SBValue APIs."""
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Create the breakpoint inside function 'main'.
-        breakpoint = target.BreakpointCreateByLocation('main.c', self.line)
+        breakpoint = target.BreakpointCreateByLocation('main.cpp', self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
         self.assertTrue(process.GetState() == lldb.eStateStopped)
def value_api(self, exe_name):
         self.DebugSBValue(pointed)
 
         # While we are at it, verify that 'my_int_ptr' points to 'g_my_int'.
         symbol = target.ResolveLoadAddress(int(pointed.GetLocation(), 0)).GetSymbol()
         self.assertTrue(symbol)
         self.expect(symbol.GetName(), exe=False,
             startstr = 'g_my_int')
 
+        # Get variable 'my_int_ref'.
+        value = frame0.FindVariable('my_int_ref')
+        self.assertTrue(value, VALID_VARIABLE)
+        self.DebugSBValue(value)
+
+        # SBValue::TypeIsPointerType() should return false.
+        self.assertFalse(value.TypeIsPointerType())
+
+        # SBValue::TypeIsReferenceType() should return true.
+        self.assertTrue(value.TypeIsReferenceType())
+
         # Get variable 'str_ptr'.
         value = frame0.FindVariable('str_ptr')
         self.assertTrue(value, VALID_VARIABLE)
         self.DebugSBValue(value)
 
         # SBValue::TypeIsPointerType() should return true.
         self.assertTrue(value.TypeIsPointerType())
 

test/python_api/value/main.cpp

 
 int main (int argc, char const *argv[])
 {
     int i;
     MyInt a = 12345;
     struct MyStruct s = { 11, 22 };
     int *my_int_ptr = &g_my_int;
     printf("my_int_ptr points to location %p\n", my_int_ptr);
+    int &my_int_ref = g_my_int;
+    printf("my_int_ref refers to location %p\n", &my_int_ref);
     const char **str_ptr = days_of_week;
     for (i = 0; i < 7; ++i)
         printf("%s\n", str_ptr[i]); // Break at this line
                                     // and do str_ptr_val.GetChildAtIndex(5, lldb.eNoDynamicValues, True).
-    
     return 0;
 }