Implement precise compiler invocations for SwiftASTContext.

To deal with the growing number of incompatible Swift language flags,
LLDB's expression evaluator can now precisely match the compiler flags
from the current breakpoint instead of attempting to build a single
compiler invocation for the entire project.

This is now possible for the first time thanks to dwim-print and the
generic expression evaluator. The feature can be controlled via
a new "symbols.swift-precise-compiler-invocation" setting.

rdar://115188886

Author: adrian-prantl

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -625,7 +625,7 @@ AddRequiredAliases(Block *block, lldb::StackFrameSP &stack_frame_sp,
     // If we are extending a generic class it's going to be a metatype,
     // and we have to grab the instance type:
     imported_self_type = swift_type_system->GetInstanceType(
-        imported_self_type.GetOpaqueQualType());
+        imported_self_type.GetOpaqueQualType(), stack_frame_sp.get());
     if (!imported_self_type)
       return Status(
           "Unable to add the aliases the expression needs because the Swift "

lldb/source/Plugins/ExpressionParser/Swift/SwiftUserExpression.cpp

@@ -145,7 +145,7 @@ findSwiftSelf(StackFrame &frame, lldb::VariableSP self_var_sp) {
   // 4) If `self` is a metatype, get its instance type.
   if (Flags(info.type.GetTypeInfo())
           .AllSet(lldb::eTypeIsSwift | lldb::eTypeIsMetatype)) {
-    info.type = TypeSystemSwift::GetInstanceType(info.type);
+    info.type = TypeSystemSwift::GetInstanceType(info.type, &frame);
     info.is_metatype = true;
   }
 
@@ -686,9 +686,11 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
   if (!frame)
     return error("couldn't start parsing - no stack frame");
 
-  auto *exe_scope = exe_ctx.GetBestExecutionContextScope();
-  if (!exe_scope)
-    return error( "no execution context scope");
+  ExecutionContextScope *exe_scope =
+      m_options.GetREPLEnabled() ? static_cast<ExecutionContextScope *>(target)
+                                 : static_cast<ExecutionContextScope *>(frame);
+
+exe_scope = exe_ctx.GetBestExecutionContextScope();
 
   m_swift_scratch_ctx = target->GetSwiftScratchContext(m_err, *exe_scope);
   if (!m_swift_scratch_ctx)
@@ -697,8 +699,9 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
 
   const SymbolContext *sc =
       &frame->GetSymbolContext(lldb::eSymbolContextFunction);
-  m_swift_ast_ctx = llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(
-      m_swift_scratch_ctx->get()->GetSwiftASTContext(sc));
+  auto *swift_ast_ctx = m_swift_scratch_ctx->get()->GetSwiftASTContext(sc);
+  m_swift_ast_ctx =
+      llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(swift_ast_ctx);
 
   if (!m_swift_ast_ctx)
     return error("could not create a Swift AST context");

lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp

@@ -1369,8 +1369,16 @@ std::unique_ptr<Language::TypeScavenger> SwiftLanguage::GetTypeScavenger() {
                 if (result_sp && result_sp->GetCompilerType().IsValid()) {
                   CompilerType result_type(result_sp->GetCompilerType());
                   if (Flags(result_type.GetTypeInfo())
-                          .AllSet(eTypeIsSwift | eTypeIsMetatype))
-                    result_type = TypeSystemSwift::GetInstanceType(result_type);
+                      .AllSet(eTypeIsSwift | eTypeIsMetatype)) {
+                    result_type = TypeSystemSwift::GetInstanceType(result_type,
+                                                                   exe_scope);
+                    if (auto swift_ast_ctx =
+                            result_type.GetTypeSystem()
+                                .dyn_cast_or_null<SwiftASTContext>())
+                      result_type = swift_ast_ctx->GetTypeSystemSwiftTypeRef()
+                                        .GetTypeFromMangledTypename(
+                                            result_type.GetMangledTypeName());
+                  }
                   results.insert(TypeOrDecl(result_type));
                 }
               }

lldb/source/Plugins/Language/Swift/SwiftMetatype.cpp

@@ -25,8 +25,9 @@ bool lldb_private::formatters::swift::SwiftMetatype_SummaryProvider(
   lldb::addr_t metadata_ptr = valobj.GetPointerValue();
   if (metadata_ptr == LLDB_INVALID_ADDRESS || metadata_ptr == 0) {
     CompilerType compiler_metatype_type(valobj.GetCompilerType());
-    CompilerType instancetype =
-      TypeSystemSwift::GetInstanceType(compiler_metatype_type);
+    ExecutionContext exe_ctx = valobj.GetExecutionContextRef();
+    CompilerType instancetype = TypeSystemSwift::GetInstanceType(
+        compiler_metatype_type, exe_ctx.GetBestExecutionContextScope());
     name = instancetype.GetDisplayTypeName();
   } else if (CompilerType meta_type = valobj.GetCompilerType()) {
     name = meta_type.GetDisplayTypeName();

lldb/source/Plugins/Language/Swift/SwiftOptionSet.cpp

@@ -72,7 +72,7 @@ lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
       m_type(clang_type), m_cases() {}
 
 void lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
-    FillCasesIfNeeded() {
+    FillCasesIfNeeded(const ExecutionContext *exe_ctx) {
   if (m_cases.has_value())
     return;
 
@@ -87,18 +87,18 @@ void lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
   // standalone and provided with a callback to read the APINote
   // information.
   auto ts = m_type.GetTypeSystem();
+  std::shared_ptr<SwiftASTContext> swift_ast_ctx;
   if (auto trts =
           ts.dyn_cast_or_null<TypeSystemSwiftTypeRef>()) {
-    m_type = trts->ReconstructType(m_type);
-    ts = m_type.GetTypeSystem();
+    m_type = trts->ReconstructType(m_type, exe_ctx);
+    swift_ast_ctx = m_type.GetTypeSystem().dyn_cast_or_null<SwiftASTContext>();
+    if (!swift_ast_ctx)
+      return;
     decl_ts = GetAsEnumDecl(m_type);
     enum_decl = decl_ts.first;
     if (!enum_decl)
       return;
   }
-  auto swift_ts = ts.dyn_cast_or_null<SwiftASTContext>();
-  if (!swift_ts)
-    return;
 
   auto iter = enum_decl->enumerator_begin(), end = enum_decl->enumerator_end();
   for (; iter != end; ++iter) {
@@ -112,7 +112,8 @@ void lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
         case_init_val = case_init_val.zext(64);
       if (case_init_val.getBitWidth() > 64)
         continue;
-      ConstString case_name(swift_ts->GetSwiftName(case_decl, *decl_ts.second));
+      ConstString case_name(
+          swift_ast_ctx->GetSwiftName(case_decl, *decl_ts.second));
       m_cases->push_back({case_init_val, case_name});
     }
   }
@@ -162,7 +163,10 @@ bool lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
   if (!ReadValueIfAny(*rawValue_sp, value))
     return false;
 
-  FillCasesIfNeeded();
+  {
+    ExecutionContext exe_ctx = valobj->GetExecutionContextRef().Lock(false);
+    FillCasesIfNeeded(&exe_ctx);
+  }
 
   StreamString ss;
   bool first_match = true;

lldb/source/Plugins/Language/Swift/SwiftOptionSet.h

@@ -41,7 +41,7 @@ struct SwiftOptionSetSummaryProvider : public TypeSummaryImpl {
   const SwiftOptionSetSummaryProvider &
   operator=(const SwiftOptionSetSummaryProvider &) = delete;
 
-  void FillCasesIfNeeded();
+  void FillCasesIfNeeded(const ExecutionContext *);
 
   CompilerType m_type;
 

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -506,8 +506,10 @@ llvm::Optional<uint64_t> SwiftLanguageRuntimeImpl::GetMemberVariableOffset(
             .GetSwiftValidateTypeSystem()) {
       // Convert to an AST type, if necessary.
       if (auto ts = instance_type.GetTypeSystem()
-                        .dyn_cast_or_null<TypeSystemSwiftTypeRef>())
-        instance_type = ts->ReconstructType(instance_type);
+                        .dyn_cast_or_null<TypeSystemSwiftTypeRef>()) {
+        ExecutionContext exe_ctx = instance->GetExecutionContextRef().Lock(false);
+        instance_type = ts->ReconstructType(instance_type, &exe_ctx);
+      }
       auto reference = GetMemberVariableOffsetRemoteAST(instance_type, instance,
                                                         member_name);
       if (reference.has_value() && offset != reference) {