Replace IsFullyRealized() with !IsMeaninglessWithoutDynamicResolution() (NFC)

This patch eliminates yet another reason to instantiate a
SwiftASTContextForModule in the expression evaluator.

rdar://113997661

Author: adrian-prantl

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

@@ -1087,8 +1087,16 @@ bool SwiftASTManipulator::AddExternalVariables(
 
       swift::VarDecl *redirected_var_decl =
           GetVarDeclForVariableInFunction(variable, containing_function);
+      if (!redirected_var_decl) {
+        LLDB_LOG(log, "No var decl.");
+        continue;
+      }
       swift::PatternBindingDecl *pattern_binding =
           GetPatternBindingForVarDecl(redirected_var_decl, containing_function);
+      if (!pattern_binding) {
+        LLDB_LOG(log, "No pattern binding.");
+        continue;
+      }
 
       // Push the var decl and pattern binding so we add them to the function
       // later.

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

@@ -491,10 +491,16 @@ CompilerType SwiftExpressionParser::ResolveVariable(
   if (!var_type.IsValid())
     return {};
 
+  auto swift_type_system =
+      var_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!swift_type_system)
+    return {};
+
   // If the type can't be realized and dynamic types are allowed, fall back to
   // the dynamic type. We can only do this when not binding generic types
   // though, as we don't bind the generic parameters in that case.
-  if (!SwiftASTContext::IsFullyRealized(var_type) &&
+  if (swift_type_system->IsMeaninglessWithoutDynamicResolution(
+          var_type.GetOpaqueQualType()) &&
       bind_generic_types != lldb::eDontBind && use_dynamic_value) {
     var_type = GetSwiftTypeForVariableValueObject(
         valobj_sp->GetDynamicValue(use_dynamic), stack_frame_sp, runtime,

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

@@ -330,10 +330,19 @@ static bool AddVariableInfo(
     return true;
   }
 
+  // Report a fatal error if self can't be reconstructed as a Swift AST type.
+  if (is_self && !GetSwiftType(target_type))
+    return false;
+
+  auto ts = target_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!ts)
+    return false;
+
   // If we couldn't fully realize the type, then we aren't going
   // to get very far making a local out of it, so discard it here.
   Log *log = GetLog(LLDBLog::Types | LLDBLog::Expressions);
-  if (!is_unbound_pack && !SwiftASTContext::IsFullyRealized(target_type)) {
+  if (!is_unbound_pack && ts->IsMeaninglessWithoutDynamicResolution(
+                              target_type.GetOpaqueQualType())) {
     if (log)
       log->Printf("Discarding local %s because we couldn't fully realize it, "
                   "our best attempt was: %s.",

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -850,12 +850,11 @@ SwiftASTContext::GetCachedEnumInfo(opaque_compiler_type_t type) {
   if (pos != enum_info_cache->end())
     return pos->second.get();
 
-  swift::CanType swift_can_type(GetCanonicalSwiftType(type));
-  if (!SwiftASTContext::IsFullyRealized(ToCompilerType({swift_can_type})))
+  if (IsMeaninglessWithoutDynamicResolution(type))
     return nullptr;
 
   SwiftEnumDescriptorSP enum_info_sp;
-
+  swift::CanType swift_can_type(GetCanonicalSwiftType(type));
   if (auto *enum_type = swift_can_type->getAs<swift::EnumType>()) {
     enum_info_sp.reset(GetEnumInfoFromEnumDecl(GetASTContext(), swift_can_type,
                                                enum_type->getDecl()));
@@ -5177,17 +5176,6 @@ SwiftASTContext::GetStaticSelfType(lldb::opaque_compiler_type_t type) {
   return {weak_from_this(), type};
 }
 
-bool SwiftASTContext::IsFullyRealized(const CompilerType &compiler_type) {
-  if (swift::CanType swift_can_type = ::GetCanonicalSwiftType(compiler_type)) {
-    if (swift::isa<swift::MetatypeType>(swift_can_type))
-      return true;
-    return !swift_can_type->hasArchetype() &&
-           !swift_can_type->hasTypeParameter();
-  }
-
-  return false;
-}
-
 bool SwiftASTContext::GetProtocolTypeInfo(const CompilerType &type,
                                           ProtocolInfo &protocol_info) {
   LLDB_SCOPED_TIMER();

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -411,11 +411,11 @@ class SwiftASTContext : public TypeSystemSwift {
   swift::CanType
   GetCanonicalSwiftType(lldb::opaque_compiler_type_t opaque_type);
 
-  // Imports the type from the passed in type into this SwiftASTContext. The
-  // type must be a Swift type. If the type can be imported, returns the
-  // CompilerType for the imported type.
-  // If it cannot be, returns an invalid CompilerType, and sets the error to
-  // indicate what went wrong.
+  /// Imports the type from the passed in type into this SwiftASTContext. The
+  /// type must be a Swift type. If the type can be imported, returns the
+  /// CompilerType for the imported type.
+  /// If it cannot be, returns an invalid CompilerType, and sets the error to
+  /// indicate what went wrong.
   CompilerType ImportType(CompilerType &type, Status &error);
 
   swift::ClangImporter *GetClangImporter();
@@ -582,8 +582,6 @@ class SwiftASTContext : public TypeSystemSwift {
   /// Whether this is the Swift error type.
   bool IsErrorType(lldb::opaque_compiler_type_t type);
 
-  static bool IsFullyRealized(const CompilerType &compiler_type);
-
   struct ProtocolInfo {
     uint32_t m_num_protocols;
     uint32_t m_num_payload_words;