Decide on the expression language inside UserExpression

[spyffe]

Summary

When the target settings are consulted to decide the expression language is decided in CommandObjectExpression, this doesn't help if you're running SBFrame::EvaluateExpression().
Moving the logic into UserExpression fixes this.

[dawn]

Please apply requested changes, then it's good to commit. Thanks for fixing this!

source/Commands/CommandObjectExpression.cpp

306 ↗

(On Diff #36029)

These lsat 6 lines can be just:

options.SetLanguage(m_command_options.language);

source/Expression/UserExpression.cpp

526 ↗

(On Diff #36029)

nit pick: remove extra line :)

lldb/trunk/source/Commands/CommandObjectExpression.cpp

if (target)
         EvaluateExpressionOptions options;
         options.SetCoerceToId(m_varobj_options.use_objc);
         options.SetUnwindOnError(m_command_options.unwind_on_error);
         options.SetIgnoreBreakpoints (m_command_options.ignore_breakpoints);
         options.SetKeepInMemory(keep_in_memory);
         options.SetUseDynamic(m_varobj_options.use_dynamic);
         options.SetTryAllThreads(m_command_options.try_all_threads);
         options.SetDebug(m_command_options.debug);
-        
-        // If the language was not specified in the expression command,
-        // set it to the language in the target's properties if
-        // specified, else default to the language for the frame.
-        if (m_command_options.language != eLanguageTypeUnknown)
-            options.SetLanguage(m_command_options.language);
-        else if (target->GetLanguage() != eLanguageTypeUnknown)
-            options.SetLanguage(target->GetLanguage());
-        else if (frame)
-            options.SetLanguage(frame->GetLanguage());
 
         // If there is any chance we are going to stop and want to see
         // what went wrong with our expression, we should generate debug info
         if (!m_command_options.ignore_breakpoints ||
             !m_command_options.unwind_on_error)
             options.SetGenerateDebugInfo(true);
         
         if (m_command_options.timeout > 0)

lldb/trunk/source/Expression/UserExpression.cpp

UserExpression::Evaluate (ExecutionContext &exe_ctx,
                                const char *expr_cstr,
                                const char *expr_prefix,
                                lldb::ValueObjectSP &result_valobj_sp,
                                Error &error)
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 
     lldb_private::ExecutionPolicy execution_policy = options.GetExecutionPolicy();
-    const lldb::LanguageType language = options.GetLanguage();
+    lldb::LanguageType language = options.GetLanguage();
     const ResultType desired_type = options.DoesCoerceToId() ? UserExpression::eResultTypeId : UserExpression::eResultTypeAny;
     lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
     
     Target *target = exe_ctx.GetTargetPtr();
     if (!target)
     {
         if (log)
             log->Printf("== [UserExpression::Evaluate] Passed a NULL target, can't run expressions.");
if (expr_prefix && option_prefix)
         if (!full_prefix_storage.empty())
             full_prefix = full_prefix_storage.c_str();
     }
     else if (expr_prefix)
         full_prefix = expr_prefix;
     else
         full_prefix = option_prefix;
 
+    // If the language was not specified in the expression command,
+    // set it to the language in the target's properties if
+    // specified, else default to the langage for the frame.
+    if (language == lldb::eLanguageTypeUnknown)
+    {
+        if (target->GetLanguage() != lldb::eLanguageTypeUnknown)
+            language = target->GetLanguage();
+        else if (StackFrame *frame = exe_ctx.GetFramePtr())
+            language = frame->GetLanguage();
+    }
+
     lldb::UserExpressionSP user_expression_sp(target->GetUserExpressionForLanguage (expr_cstr,
                                                                                     full_prefix,
                                                                                     language,
                                                                                     desired_type,
                                                                                     error));
     if (error.Fail())
     {
         if (log)