Fix warnings preventing copy elision.

[wttsugrii]

Summary

Moving a temporary object prevents copy elision, which is exactly
what clang points out by warning about this pattern.

The fix is simply removal of std::move applied to temporary objects.

[wttsugrii]

Thanks for the review @clayborg. Could someone please commit this patch to lldb repo?

[labath]

committed in r279724.

tools/debugserver/source/JSON.cpp

switch (ch)
             {
                 while (1)
                 {
                     bool was_escaped = false;
                     int escaped_ch = GetEscapedChar(was_escaped);
                     if (escaped_ch == -1)
                     {
                         error << "error: an error occurred getting a character from offset " <<start_index;
-                        value = std::move(error.str());
+                        value = error.str();
                         return Token::Error;
 
                     }
                     else
                     {
                         const bool is_end_quote = escaped_ch == '"';
                         const bool is_null = escaped_ch == 0;
                         if (was_escaped || (!is_end_quote && !is_null))
                         {
                             if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX)
                             {
                                 value.append(1, (char)escaped_ch);
                             }
                             else
                             {
                                 error << "error: wide character support is needed for unicode character 0x" << std::setprecision(4) << std::hex << escaped_ch;
                                 error << " at offset " << start_index;
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                         }
                         else if (is_end_quote)
                         {
                             return Token::String;
                         }
                         else if (is_null)
switch (ch)
                             }
                             ++m_index; // Skip this character
                             break;
 
                         case '.':
                             if (got_decimal_point)
                             {
                                 error << "error: extra decimal point found at offset " << start_index;
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                             else
                             {
                                 got_decimal_point = true;
                                 ++m_index; // Skip this character
                             }
                             break;
 
                         case 'e':
                         case 'E':
                             if (exp_index != 0)
                             {
                                 error << "error: extra exponent character found at offset " << start_index;
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                             else
                             {
                                 exp_index = m_index;
                                 ++m_index; // Skip this character
                             }
                             break;
 
                         case '+':
                         case '-':
                             // The '+' and '-' can only come after an exponent character...
                             if (exp_index == m_index - 1)
                             {
                                 ++m_index; // Skip the exponent sign character
                             }
                             else
                             {
                                 error << "error: unexpected " << next_ch << " character at offset " << start_index;
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                             break;
 
                         default:
                             done = true;
                             break;
                     }
switch (ch)
                             // We have an exponent, make sure we got exponent digits
                             if (got_exp_digits)
                             {
                                 return Token::Float;
                             }
                             else
                             {
                                 error << "error: got exponent character but no exponent digits at offset in float value \"" << value.c_str() << "\"";
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                         }
                         else
                         {
                             // No exponent, but we need at least one decimal after the decimal point
                             if (got_frac_digits)
                             {
                                 return Token::Float;
                             }
                             else
                             {
                                 error << "error: no digits after decimal point \"" << value.c_str() << "\"";
-                                value = std::move(error.str());
+                                value = error.str();
                                 return Token::Error;
                             }
                         }
                     }
                     else
                     {
                         // No decimal point
                         if (got_int_digits)
                         {
                             // We need at least some integer digits to make an integer
                             return Token::Integer;
                         }
                         else
                         {
                             error << "error: no digits negate sign \"" << value.c_str() << "\"";
-                            value = std::move(error.str());
+                            value = error.str();
                             return Token::Error;
                         }
                     }
                 }
                 else
                 {
                     error << "error: invalid number found at offset " << start_index;
-                    value = std::move(error.str());
+                    value = error.str();
                     return Token::Error;
                 }
             }
             break;
         default:
             break;
     }
     error << "error: failed to parse token at offset " << start_index << " (around character '" << ch << "')";
-    value = std::move(error.str());
+    value = error.str();
     return Token::Error;
 }
 
 int
 JSONParser::GetEscapedChar(bool &was_escaped)
 {
     was_escaped = false;
     const char ch = GetChar();