Use uint64_t for GoArray size.

[brucem]

Summary

This was int64_t, but all usages of it came from code that was passing
in unsigned values. The usages of the array size, except for one, were
also treating it as an unsigned value. The usage that treated it as
signed was to try to figure out if it was a complete type or not, but
the callers creating the array didn't seem to be aware of using -1 as
an indicator for an incomplete array.

[brucem]

This is meant to fix this warning:

llvm/tools/lldb/source/Symbol/GoASTContext.cpp:1107:40: warning: comparison of integers of different signs: 'size_t' (aka 'unsigned long') and 'int64_t' (aka 'long long') [-Wsign-compare]
        if (ignore_array_bounds || idx < a->GetLength())
                                   ~~~ ^ ~~~~~~~~~~~~~~
1 warning generated.

[ribrdb]

Looks good

lldb/trunk/include/lldb/Symbol/GoASTContext.h

public:
     {
         return false;
     }
 
     //----------------------------------------------------------------------
     // Creating Types
     //----------------------------------------------------------------------
 
-    CompilerType CreateArrayType(const ConstString &name, const CompilerType &element_type, int64_t length);
+    CompilerType CreateArrayType(const ConstString &name, const CompilerType &element_type, uint64_t length);
 
     CompilerType CreateBaseType(int go_kind, const ConstString &type_name_const_str, uint64_t byte_size);
 
     // For interface, map, chan.
     CompilerType CreateTypedef(int kind, const ConstString &name, CompilerType impl);
 
     CompilerType CreateVoidType(const ConstString &name);
     CompilerType CreateFunctionType(const lldb_private::ConstString &name, CompilerType *params, size_t params_count,

lldb/trunk/source/Symbol/GoASTContext.cpp

private:
 
     GoElem(const GoElem &) = delete;
     const GoElem &operator=(const GoElem &) = delete;
 };
 
 class GoArray : public GoElem
 {
   public:
-    GoArray(const ConstString &name, int64_t length, const CompilerType &elem)
+    GoArray(const ConstString &name, uint64_t length, const CompilerType &elem)
         : GoElem(KIND_ARRAY, name, elem)
         , m_length(length)
     {
     }
 
-    int64_t
+    uint64_t
     GetLength() const
     {
         return m_length;
     }
 
   private:
-    int64_t m_length;
+    uint64_t m_length;
     GoArray(const GoArray &) = delete;
     const GoArray &operator=(const GoArray &) = delete;
 };
 
 class GoFunction : public GoType
 {
   public:
     GoFunction(const ConstString &name, bool is_variadic)
if (element_type)
         element_type->Clear();
     if (size)
         *size = 0;
     if (is_incomplete)
         *is_incomplete = false;
     GoArray *array = static_cast<GoType *>(type)->GetArray();
     if (array)
     {
-        if (array->GetLength() == -1)
-        {
-            if (is_incomplete)
-            {
-                *is_incomplete = true;
-            }
-        }
-        else if (size)
+        if (size)
         {
             *size = array->GetLength();
         }
         if (element_type)
             *element_type = array->GetElementType();
         return true;
     }
     return false;

 
 void
 GoASTContext::DumpTypeDescription(void *type, Stream *s)
 {
     assert(false);
 }
 
 CompilerType
-GoASTContext::CreateArrayType(const ConstString &name, const CompilerType &element_type, int64_t length)
+GoASTContext::CreateArrayType(const ConstString &name, const CompilerType &element_type, uint64_t length)
 {
     GoType *type = new GoArray(name, length, element_type);
     (*m_types)[name].reset(type);
     return CompilerType(this, type);
 }
 
 CompilerType
 GoASTContext::CreateBaseType(int go_kind, const lldb_private::ConstString &name, uint64_t byte_size)