[lldb] Allow LLDB to automatically retry a failed expression with an import std C++ module

[teemperor]

Summary

By now LLDB can import the 'std' C++ module to improve expression evaluation, but there are still a
few problems to solve before we can do this by default. One is that importing the C++ module is slightly slower
than normal expression evaluation (mostly because the disk access and loading the initial lookup data is quite
slow in comparison to the barebone Clang setup the rest of the LLDB expression evaluator is usually doing).
Another problem is that some complicated types in the standard library aren't fully supported yet by the ASTImporter,
so we end up types that fail to import (which usually appears to the user as if the type is empty or there is just
no result variable).

To still allow people to adopt this mode in their daily debugging, this patch adds a setting that allows LLDB to
automatically retry failed expression with a loaded C++ module. All success expressions will behave exactly as
they would do before this patch. Failed expressions get a another parse attempt if we find a usable C++ module
in the current execution context. This way we shouldn't have any performance/parsing regressions in normal debugging
workflows, while the debugging workflows involving STL containers benefit from the C++ module type info.

This setting is off by default for now with the intention to enable it by default on macOS soon-ish.

The implementation is mostly just extracting the existing parse logic into its own function and then calling the parse
function again if the first evaluation failed and we have a C++ module to retry the parsing with.

[JDevlieghere]

Would it make sense to convert import-std-module to an enum with values True, False and Fallback instead of introducing a new option and then changing the default over time?

[aprantl]

Nice!

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

558–561

In swift-lldb we also have a really ad-hoc retry mechanism: https://github.com/apple/llvm-project/blob/2919e1a2e5019874375b880afd473d2744b5cada/lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp#L1465

I wonder if we could/should make retrying an official part of the interface?

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

180

nit: \see

243

\see

lldb/source/Plugins/ExpressionParser/Clang/CppModuleConfiguration.h

77 ↗

(On Diff #309997)

Is that because it isn't safe to return the reference?

[shafik]

LGTM but I have one questions and I am also curious about Adrian's question about returning by reference.

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/TestRetryWithStdModule.py

66

Should we try setting it to false and make sure it fails like we expect?

[teemperor]

In D92784#2437994, @JDevlieghere wrote:

Would it make sense to convert import-std-module to an enum with values True, False and Fallback instead of introducing a new option and then changing the default over time?

I actually think that makes much more sense than the current version. I changed it (but I kept the string values lowercase to be consistent with the other settings). Thanks!

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

558–561

I can look into that, but if we unify this code we can effectively only share the if (should_retry) line. And then the interface would need to be able to express "retry with C++ modules" in a language-independent way (bool retry_harder?).

When I was implementing the retrying-fixits-multiple-times I already thought that we probably should go the other way and make the UserExpression interface much smaller. The generic UserExpression stuff knows a lot about the implementation that it really shouldn't (like, that there are Fix-Its and that they might need to be applied multiple times, etc.).

lldb/source/Plugins/ExpressionParser/Clang/CppModuleConfiguration.h

77 ↗

(On Diff #309997)

Yes, but actually that was just a WIP change that slipped into the git commit. I changed that to a vector before I realized that ArrayRef defines operator std::vector<T> to do this automatically for us. I reverted that change.

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/TestRetryWithStdModule.py

66

Makes sense, done!

[teemperor]

• Now using one setting with a backing enum (Thanks Jonas)
• Gave up on imposing my doxygen code style on the project (Thanks Adrian).
• Expanded test (Thanks Shafik)

[JDevlieghere]

LGTM

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

660

Does this add anything? Would this be a good opportunity to get rid of these weird comments/banners?

[teemperor]

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

660

Well they're kinda useful if our functions are a 1000 lines long :) (but yes, they should be replaced by normal functions)

lldb/include/lldb/Target/Target.h

 };
 
 enum LoadDependentFiles {
   eLoadDependentsDefault,
   eLoadDependentsYes,
   eLoadDependentsNo,
 };
 
+enum ImportStdModule {
+  eImportStdModuleFalse,
+  eImportStdModuleFallback,
+  eImportStdModuleTrue,
+};
+
 class TargetExperimentalProperties : public Properties {
 public:
   TargetExperimentalProperties();
 };
 
 class TargetProperties : public Properties {
 public:
   TargetProperties(Target *target);
public:
   void AppendExecutableSearchPaths(const FileSpec &);
 
   FileSpecList GetDebugFileSearchPaths();
 
   FileSpecList GetClangModuleSearchPaths();
 
   bool GetEnableAutoImportClangModules() const;
 
-  bool GetEnableImportStdModule() const;
+  ImportStdModule GetImportStdModule() const;
 
   bool GetEnableAutoApplyFixIts() const;
 
   uint64_t GetNumberOfRetriesWithFixits() const;
 
   bool GetEnableNotifyAboutFixIts() const;
 
   bool GetEnableSaveObjects() const;

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

void ResetDeclMap(ExecutionContext &exe_ctx,
     m_type_system_helper.ResetDeclMap(exe_ctx, result_delegate,
                                       keep_result_in_memory,
                                       m_ctx_obj);
   }
 
   lldb::ExpressionVariableSP
   GetResultAfterDematerialization(ExecutionContextScope *exe_scope) override;
 
-  bool DidImportCxxModules() const { return m_imported_cpp_modules; }
+  /// Returns true iff this expression is using any imported C++ modules.
+  bool DidImportCxxModules() const { return !m_imported_cpp_modules.empty(); }
 
 private:
   /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the
   /// environment.
 
+  /// Contains the actual parsing implementation.
+  /// The parameter have the same meaning as in ClangUserExpression::Parse.
+  /// \see ClangUserExpression::Parse
+  bool TryParse(DiagnosticManager &diagnostic_manager,
+                ExecutionContextScope *exe_scope, ExecutionContext &exe_ctx,
+                lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory,
+                bool generate_debug_info);
+
+  void SetupCppModuleImports(ExecutionContext &exe_ctx);
+
   void ScanContext(ExecutionContext &exe_ctx,
                    lldb_private::Status &err) override;
 
   bool AddArguments(ExecutionContext &exe_ctx, std::vector<lldb::addr_t> &args,
                     lldb::addr_t struct_address,
                     DiagnosticManager &diagnostic_manager) override;
 
   void CreateSourceCode(DiagnosticManager &diagnostic_manager,
private:
 
   /// The absolute character position in the transformed source code where the
   /// user code (as typed by the user) starts. If the variable is empty, then we
   /// were not able to calculate this position.
   llvm::Optional<size_t> m_user_expression_start_pos;
   ResultDelegate m_result_delegate;
   ClangPersistentVariables *m_clang_state;
   std::unique_ptr<ClangExpressionSourceCode> m_source_code;
+  /// The parser instance we used to parse the expression.
+  std::unique_ptr<ClangExpressionParser> m_parser;
   /// File name used for the expression.
   std::string m_filename;
 
   /// The object (if any) in which context the expression is evaluated.
   /// See the comment to `UserExpression::Evaluate` for details.
   ValueObject *m_ctx_obj;
 
-  /// True iff this expression explicitly imported C++ modules.
-  bool m_imported_cpp_modules = false;
+  /// A list of module names that should be imported when parsing.
+  /// \see CppModuleConfiguration::GetImportedModules
+  std::vector<std::string> m_imported_cpp_modules;
 
   /// True if the expression parser should enforce the presence of a valid class
   /// pointer in order to generate the expression as a method.
   bool m_enforce_valid_object = true;
   /// True if the expression is compiled as a C++ member function (true if it
   /// was parsed when exe_ctx was in a C++ method).
   bool m_in_cplusplus_method = false;
   /// True if the expression is compiled as an Objective-C method (true if it

lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp

ClangExpressionSourceCode::WrapKind ClangUserExpression::GetWrapKind() const {
   // function.
   return Kind::Function;
 }
 
 void ClangUserExpression::CreateSourceCode(
     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
     std::vector<std::string> modules_to_import, bool for_completion) {
 
-  m_filename = m_clang_state->GetNextExprFileName();
   std::string prefix = m_expr_prefix;
 
   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
     m_transformed_text = m_expr_text;
   } else {
     m_source_code.reset(ClangExpressionSourceCode::CreateWrapped(
         m_filename, prefix, m_expr_text, GetWrapKind()));
 
CppModuleConfiguration GetModuleConfig(lldb::LanguageType language,
   // Don't do anything if this is not a C++ module configuration.
   if (!SupportsCxxModuleImport(language))
     return LogConfigError("Language doesn't support C++ modules");
 
   Target *target = exe_ctx.GetTargetPtr();
   if (!target)
     return LogConfigError("No target");
 
-  if (!target->GetEnableImportStdModule())
-    return LogConfigError("Importing std module not enabled in settings");
-
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (!frame)
     return LogConfigError("No frame");
 
   Block *block = frame->GetFrameBlock();
   if (!block)
     return LogConfigError("No block");
 
CppModuleConfiguration GetModuleConfig(lldb::LanguageType language,
   // configuration possible with the files, this just returns an invalid
   // configuration.
   return CppModuleConfiguration(files);
 }
 
 bool ClangUserExpression::PrepareForParsing(
     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
     bool for_completion) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
-
   InstallContext(exe_ctx);
 
   if (!SetupPersistentState(diagnostic_manager, exe_ctx))
     return false;
 
   Status err;
   ScanContext(exe_ctx, err);
 
   if (!err.Success()) {
     diagnostic_manager.PutString(eDiagnosticSeverityWarning, err.AsCString());
   }
 
   ////////////////////////////////////
   // Generate the expression
   //
 
   ApplyObjcCastHack(m_expr_text);
 
   SetupDeclVendor(exe_ctx, m_target, diagnostic_manager);
 
-  CppModuleConfiguration module_config = GetModuleConfig(m_language, exe_ctx);
-  llvm::ArrayRef<std::string> imported_modules =
-      module_config.GetImportedModules();
-  m_imported_cpp_modules = !imported_modules.empty();
-  m_include_directories = module_config.GetIncludeDirs();
+  m_filename = m_clang_state->GetNextExprFileName();
 
-  LLDB_LOG(log, "List of imported modules in expression: {0}",
-           llvm::make_range(imported_modules.begin(), imported_modules.end()));
-  LLDB_LOG(log, "List of include directories gathered for modules: {0}",
-           llvm::make_range(m_include_directories.begin(),
-                            m_include_directories.end()));
+  if (m_target->GetImportStdModule() == eImportStdModuleTrue)
+    SetupCppModuleImports(exe_ctx);
 
-  CreateSourceCode(diagnostic_manager, exe_ctx, imported_modules,
+  CreateSourceCode(diagnostic_manager, exe_ctx, m_imported_cpp_modules,
                    for_completion);
   return true;
 }
 
-bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
-                                ExecutionContext &exe_ctx,
-                                lldb_private::ExecutionPolicy execution_policy,
-                                bool keep_result_in_memory,
-                                bool generate_debug_info) {
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
-
-  if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ false))
-    return false;
-
-  LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
-
-  ////////////////////////////////////
-  // Set up the target and compiler
-  //
-
-  Target *target = exe_ctx.GetTargetPtr();
-
-  if (!target) {
-    diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
-    return false;
-  }
-
-  //////////////////////////
-  // Parse the expression
-  //
-
+bool ClangUserExpression::TryParse(
+    DiagnosticManager &diagnostic_manager, ExecutionContextScope *exe_scope,
+    ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy,
+    bool keep_result_in_memory, bool generate_debug_info) {
   m_materializer_up = std::make_unique<Materializer>();
 
   ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
 
   auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); });
 
   if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) {
     diagnostic_manager.PutString(
         eDiagnosticSeverityError,
         "current process state is unsuitable for expression parsing");
     return false;
   }
 
   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
     DeclMap()->SetLookupsEnabled(true);
   }
 
-  Process *process = exe_ctx.GetProcessPtr();
-  ExecutionContextScope *exe_scope = process;
-
-  if (!exe_scope)
-    exe_scope = exe_ctx.GetTargetPtr();
-
-  // We use a shared pointer here so we can use the original parser - if it
-  // succeeds or the rewrite parser we might make if it fails.  But the
-  // parser_sp will never be empty.
-
-  ClangExpressionParser parser(exe_scope, *this, generate_debug_info,
-                               m_include_directories, m_filename);
+  m_parser = std::make_unique<ClangExpressionParser>(
+      exe_scope, *this, generate_debug_info, m_include_directories, m_filename);
 
-  unsigned num_errors = parser.Parse(diagnostic_manager);
+  unsigned num_errors = m_parser->Parse(diagnostic_manager);
 
   // Check here for FixItHints.  If there are any try to apply the fixits and
   // set the fixed text in m_fixed_text before returning an error.
   if (num_errors) {
     if (diagnostic_manager.HasFixIts()) {
-      if (parser.RewriteExpression(diagnostic_manager)) {
+      if (m_parser->RewriteExpression(diagnostic_manager)) {
         size_t fixed_start;
         size_t fixed_end;
         m_fixed_text = diagnostic_manager.GetFixedExpression();
         // Retrieve the original expression in case we don't have a top level
         // expression (which has no surrounding source code).
         if (m_source_code && m_source_code->GetOriginalBodyBounds(
                                  m_fixed_text, fixed_start, fixed_end))
           m_fixed_text =
               m_fixed_text.substr(fixed_start, fixed_end - fixed_start);
       }
     }
     return false;
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Prepare the output of the parser for execution, evaluating it statically
   // if possible
   //
 
   {
-    Status jit_error = parser.PrepareForExecution(
+    Status jit_error = m_parser->PrepareForExecution(
         m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
         m_can_interpret, execution_policy);
 
     if (!jit_error.Success()) {
       const char *error_cstr = jit_error.AsCString();
       if (error_cstr && error_cstr[0])
         diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
       else
         diagnostic_manager.PutString(eDiagnosticSeverityError,
                                      "expression can't be interpreted or run");
       return false;
     }
   }
+  return true;
+}
+
+void ClangUserExpression::SetupCppModuleImports(ExecutionContext &exe_ctx) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  CppModuleConfiguration module_config = GetModuleConfig(m_language, exe_ctx);
+  m_imported_cpp_modules = module_config.GetImportedModules();
+  m_include_directories = module_config.GetIncludeDirs();
+
+  LLDB_LOG(log, "List of imported modules in expression: {0}",
+           llvm::make_range(m_imported_cpp_modules.begin(),
+                            m_imported_cpp_modules.end()));
+  LLDB_LOG(log, "List of include directories gathered for modules: {0}",
+           llvm::make_range(m_include_directories.begin(),
+                            m_include_directories.end()));
+}
+
+static bool shouldRetryWithCppModule(Target &target, ExecutionPolicy exe_policy) {
+  // Top-level expression don't yet support importing C++ modules.
+  if (exe_policy == ExecutionPolicy::eExecutionPolicyTopLevel)
+    return false;
+  return target.GetImportStdModule() == eImportStdModuleFallback;
+}
+
+bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
+                                ExecutionContext &exe_ctx,
+                                lldb_private::ExecutionPolicy execution_policy,
+                                bool keep_result_in_memory,
+                                bool generate_debug_info) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ false))
+    return false;
+
+  LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
+
+  ////////////////////////////////////
+  // Set up the target and compiler
+  //
+
+  Target *target = exe_ctx.GetTargetPtr();
+
+  if (!target) {
+    diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
+    return false;
+  }
+
+  //////////////////////////
+  // Parse the expression
+  //
+
+  Process *process = exe_ctx.GetProcessPtr();
+  ExecutionContextScope *exe_scope = process;
+
+  if (!exe_scope)
+    exe_scope = exe_ctx.GetTargetPtr();
+
+  bool parse_success = TryParse(diagnostic_manager, exe_scope, exe_ctx,
+                                execution_policy, keep_result_in_memory,
+                                generate_debug_info);
+  // If the expression failed to parse, check if retrying parsing with a loaded
+  // C++ module is possible.
+  if (!parse_success && shouldRetryWithCppModule(*target, execution_policy)) {
+    // Load the loaded C++ modules.
+    SetupCppModuleImports(exe_ctx);
+    // If we did load any modules, then retry parsing.
+    if (!m_imported_cpp_modules.empty()) {
+      // The module imports are injected into the source code wrapper,
+      // so recreate those.
+      CreateSourceCode(diagnostic_manager, exe_ctx, m_imported_cpp_modules,
+                       /*for_completion*/ false);
+      // Clear the error diagnostics from the previous parse attempt.
+      diagnostic_manager.Clear();
+      parse_success = TryParse(diagnostic_manager, exe_scope, exe_ctx,
+                               execution_policy, keep_result_in_memory,
+                               generate_debug_info);
+    }
+  }
+  if (!parse_success)
+    return false;
 
   if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) {
     Status static_init_error =
-        parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
+        m_parser->RunStaticInitializers(m_execution_unit_sp, exe_ctx);
 
     if (!static_init_error.Success()) {
       const char *error_cstr = static_init_error.AsCString();
       if (error_cstr && error_cstr[0])
         diagnostic_manager.Printf(eDiagnosticSeverityError,
                                   "%s\n",
                                   error_cstr);
       else

lldb/source/Target/Target.cpp

static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[] = {
     },
     {
         eX86DisFlavorATT,
         "att",
         "AT&T disassembler flavor.",
     },
 };
 
+static constexpr OptionEnumValueElement g_import_std_module_value_types[] = {
+    {
+        eImportStdModuleFalse,
+        "false",
+        "Never import the 'std' C++ module in the expression parser.",
+    },
+    {
+        eImportStdModuleFallback,
+        "fallback",
+        "Retry evaluating expressions with an imported 'std' C++ module if they"
+        " failed to parse without the module. This allows evaluating more "
+        "complex expressions involving C++ standard library types."
+    },
+    {
+        eImportStdModuleTrue,
+        "true",
+        "Always import the 'std' C++ module. This allows evaluating more "
+        "complex expressions involving C++ standard library types. This feature"
+        " is experimental."
+    },
+};
+
 static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = {
     {
         Disassembler::eHexStyleC,
         "c",
         "C-style (0xffff).",
     },
     {
         Disassembler::eHexStyleAsm,

 }
 
 bool TargetProperties::GetEnableAutoImportClangModules() const {
   const uint32_t idx = ePropertyAutoImportClangModules;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_target_properties[idx].default_uint_value != 0);
 }
 
-bool TargetProperties::GetEnableImportStdModule() const {
+ImportStdModule TargetProperties::GetImportStdModule() const {
   const uint32_t idx = ePropertyImportStdModule;
-  return m_collection_sp->GetPropertyAtIndexAsBoolean(
-      nullptr, idx, g_target_properties[idx].default_uint_value != 0);
+  return (ImportStdModule)m_collection_sp->GetPropertyAtIndexAsEnumeration(
+      nullptr, idx, g_target_properties[idx].default_uint_value);
 }
 
 bool TargetProperties::GetEnableAutoApplyFixIts() const {
   const uint32_t idx = ePropertyAutoApplyFixIts;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_target_properties[idx].default_uint_value != 0);
 }
 

lldb/source/Target/TargetProperties.td

def DebugFileSearchPaths: Property<"debug-file-search-paths", "FileSpecList">,
     DefaultStringValue<"">,
     Desc<"List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup.">;
   def ClangModuleSearchPaths: Property<"clang-module-search-paths", "FileSpecList">,
     DefaultStringValue<"">,
     Desc<"List of directories to be searched when locating modules for Clang.">;
   def AutoImportClangModules: Property<"auto-import-clang-modules", "Boolean">,
     DefaultTrue,
     Desc<"Automatically load Clang modules referred to by the program.">;
-  def ImportStdModule: Property<"import-std-module", "Boolean">,
-    DefaultFalse,
-    Desc<"Import the C++ std module to improve debugging STL containers.">;
+  def ImportStdModule: Property<"import-std-module", "Enum">,
+    DefaultEnumValue<"eImportStdModuleFalse">,
+    EnumValues<"OptionEnumValues(g_import_std_module_value_types)">,
+    Desc<"Import the 'std' C++ module to improve expression parsing involving "
+         " C++ standard library types.">;
   def AutoApplyFixIts: Property<"auto-apply-fixits", "Boolean">,
     DefaultTrue,
     Desc<"Automatically apply fix-it hints to expressions.">;
   def RetriesWithFixIts: Property<"retries-with-fixits", "UInt64">,
     DefaultUnsignedValue<1>,
     Desc<"Maximum number of attempts to fix an expression with Fix-Its">;
   def NotifyAboutFixIts: Property<"notify-about-fixits", "Boolean">,
     DefaultTrue,

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/Makefile

+USE_LIBCPP := 1
+CXX_SOURCES := main.cpp
+include Makefile.rules

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/TestRetryWithStdModule.py

+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @add_test_categories(["libc++"])
+    @skipIf(compiler=no_match("clang"))
+    def test(self):
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self,
+                                          "// Set break point at this line.",
+                                          lldb.SBFileSpec("main.cpp"))
+
+        # Test printing the vector before enabling any C++ module setting.
+        self.expect_expr("a", result_type="std::vector<int, std::allocator<int> >")
+
+        # Set loading the import-std-module to 'fallback' which loads the module
+        # and retries when an expression fails to parse.
+        self.runCmd("settings set target.import-std-module fallback")
+
+        # Printing the vector still works. This should return the same type
+        # as before as this shouldn't use a C++ module type (the C++ module type
+        # is hiding the second template parameter as it's equal to the default
+        # argument which the C++ module has type info for).
+        self.expect_expr("a", result_type="std::vector<int, std::allocator<int> >")
+
+        # This expression can only parse with a C++ module. LLDB should
+        # automatically fall back to import the C++ module to get this working.
+        self.expect_expr("std::max<std::size_t>(0U, a.size())", result_value="3")
+
+
+        # The 'a' and 'local' part can be parsed without loading a C++ module and will
+        # load type/runtime information. The 'std::max...' part will fail to
+        # parse without a C++ module. Make sure we reset all the relevant parts of
+        # the C++ parser so that we don't end up with for example a second
+        # definition of 'local' when retrying.
+        self.expect_expr("a; local; std::max<std::size_t>(0U, a.size())", result_value="3")
+
+
+        # Try to declare top-level declarations that require a C++ module to parse.
+        # Top-level expressions don't support importing the C++ module (yet), so
+        # this should still fail as before.
+        self.expect("expr --top-level -- int i = std::max(1, 2);", error=True,
+                    substrs=["no member named 'max' in namespace 'std'"])
+
+        # Check that diagnostics from the first parse attempt don't show up
+        # in the C++ module parse attempt. In the expression below, we first
+        # fail to parse 'std::max'. Then we retry with a loaded C++ module
+        # and succeed to parse the 'std::max' part. However, the
+        # trailing 'unknown_identifier' will fail to parse even with the
+        # loaded module. The 'std::max' diagnostic from the first attempt
+        # however should not be shown to the user.
+        self.expect("expr std::max(1, 2); unknown_identifier", error=True,
+                    matching=False,
+                    substrs=["no member named 'max'"])
+        # The proper diagnostic however should be shown on the retry.
+        self.expect("expr std::max(1, 2); unknown_identifier", error=True,
+                    substrs=["use of undeclared identifier 'unknown_identifier'"])
+
+        # Turn on the 'import-std-module' setting and make sure we import the
+        # C++ module.
+        self.runCmd("settings set target.import-std-module true")
+        # This is still expected to work.
+        self.expect_expr("std::max<std::size_t>(0U, a.size())", result_value="3")
+
+        # Turn of the 'import-std-module' setting and make sure we don't load
+        # the module (which should prevent parsing the expression involving
+        # 'std::max').
+        self.runCmd("settings set target.import-std-module false")
+        self.expect("expr std::max(1, 2);", error=True,
+                    substrs=["no member named 'max' in namespace 'std'"])

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/main.cpp

+#include <vector>
+
+int main(int argc, char **argv) {
+  std::vector<int> a = {3, 1, 2};
+  int local = 3;
+  return 0; // Set break point at this line.
+}