Track expression language from one place in ClangExpressionParser

[ldrumm]

Summary

The current expression language is currently tracked in a few places within the ClangExpressionParser constructor. This patch adds a private lldb::LanguageType attribute to the ClangExpressionParser class and tracks the expression language from that one place.

[clayborg]

I will let Sean review this one as the expression parser is his area of expertise.

[ldrumm]

Updated diff to show full context

[ldrumm]

Hi all

If there are no objections, I'd like to commit this. Is this in an acceptable state?

Best

Luke

[ldrumm]

Hi all

I'm still keen to have someone more familiar with this code to let me know if anything's amiss, but I'll probably move ahead and commit this tomorrow if I don't hear anything.
Let me know if you'd like any changes made - or the patch is simply rotten to the core - and I'll take another shot at it

Best

Luke

[ldrumm]

This patch was committed back in March https://reviews.llvm.org/rL263099 and then reverted 2 hours later in https://reviews.llvm.org/rL263107 due to a testing failure on greendragon related to ObjC. Unfortunately, I no longer have access to Apple hardware (and at the time the testsuite passed on my local mac), so I'm unable to find out exactly what went wrong.

This patch is still needed for RenderScript to handle JIT expressions correctly, so I'd really appreciate it if someone more familiar with OS X would be able to take a look at this, and point out what I'm doing wrong that causes the Objective C tests to blow up.

Any help is - as always - very-much appreciated!

[ldrumm]

This patch was committed back in March https://reviews.llvm.org/rL263099 and then reverted 2 hours later in https://reviews.llvm.org/rL263107 due to a testing failure on greendragon related to ObjC. Unfortunately, I no longer have access to Apple hardware (and at the time the testsuite passed on my local mac), so I'm unable to find out exactly what went wrong.

This patch is still needed for RenderScript to handle JIT expressions correctly, so I'd really appreciate it if someone more familiar with OS X would be able to take a look at this, and point out what I'm doing wrong that causes the Objective C tests to blow up.

Any help is - as always - very-much appreciated!

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

private:
     std::unique_ptr<clang::CompilerInstance> m_compiler;             ///< The Clang compiler used to parse expressions into IR
     std::unique_ptr<clang::Builtin::Context> m_builtin_context;      ///< Context for Clang built-ins
     std::unique_ptr<clang::SelectorTable>    m_selector_table;       ///< Selector table for Objective-C methods
     std::unique_ptr<clang::CodeGenerator>    m_code_generator;       ///< The Clang object that generates IR
     
     class LLDBPreprocessorCallbacks;
     LLDBPreprocessorCallbacks               *m_pp_callbacks;         ///< Called when the preprocessor encounters module imports
     std::unique_ptr<ClangASTContext>         m_ast_context;
+    lldb::LanguageType                       m_language;            ///< The the source language of the expression
+                                                                    /// which may be explicitly set or inferred.
 };
     
 }
 
 #endif  // liblldb_ClangExpressionParser_h_

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

ClangExpressionParser::ClangExpressionParser (ExecutionContextScope *exe_scope,
     m_compiler (),
     m_code_generator (),
     m_pp_callbacks(nullptr)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     // 1. Create a new compiler instance.
     m_compiler.reset(new CompilerInstance());
-    lldb::LanguageType frame_lang = expr.Language(); // defaults to lldb::eLanguageTypeUnknown
+    m_language = expr.Language(); // defaults to lldb::eLanguageTypeUnknown
     bool overridden_target_opts = false;
     lldb_private::LanguageRuntime *lang_rt = nullptr;
     lldb::TargetSP target_sp;
     if (exe_scope)
         target_sp = exe_scope->CalculateTarget();
 
     ArchSpec target_arch;
     if (target_sp)
         target_arch = target_sp->GetArchitecture();
 
     const auto target_machine = target_arch.GetMachine();
 
     // If the expression is being evaluated in the context of an existing
     // stack frame, we introspect to see if the language runtime is available.
     auto frame = exe_scope->CalculateStackFrame();
 
     // Make sure the user hasn't provided a preferred execution language
     // with `expression --language X -- ...`
-    if (frame && frame_lang == lldb::eLanguageTypeUnknown)
-        frame_lang = frame->GetLanguage();
+    if (frame && m_language == lldb::eLanguageTypeUnknown)
+        m_language = frame->GetLanguage();
 
-    if (frame_lang != lldb::eLanguageTypeUnknown)
+    if (m_language != lldb::eLanguageTypeUnknown)
     {
-        lang_rt = exe_scope->CalculateProcess()->GetLanguageRuntime(frame_lang);
+        lang_rt = exe_scope->CalculateProcess()->GetLanguageRuntime(m_language);
         if (log)
-            log->Printf("Frame has language of type %s", Language::GetNameForLanguageType(frame_lang));
+            log->Printf("Frame has language of type %s", Language::GetNameForLanguageType(m_language));
     }
 
     // 2. Configure the compiler with a set of default options that are appropriate
     // for most situations.
     if (target_sp && target_arch.IsValid())
     {
         std::string triple = target_arch.GetTriple().str();
         m_compiler->getTargetOpts().Triple = triple;
if (log)
         log->Printf("Target ABI: '%s'", target_info->getABI().str().c_str());
         log->Printf("Target vector alignment: %d", target_info->getMaxVectorAlign());
     }
     m_compiler->setTarget(target_info);
 
     assert (m_compiler->hasTarget());
 
     // 5. Set language options.
-    lldb::LanguageType language = expr.Language();
-
-    switch (language)
+    switch (m_language)
     {
     case lldb::eLanguageTypeC:
     case lldb::eLanguageTypeC89:
     case lldb::eLanguageTypeC99:
     case lldb::eLanguageTypeC11:
         // FIXME: the following language option is a temporary workaround,
         // to "ask for C, get C++."
         // For now, the expression parser must use C++ anytime the