Merge pull request #26524 from slavapestov/irgen-validate-decl-fix

IRGen: Fix crash if the type of a class stored property hasn't been validated yet

Author: slavapestov

lib/IRGen/GenClass.cpp

@@ -22,7 +22,6 @@
 #include "swift/AST/AttrKind.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/IRGenOptions.h"
-#include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrettyStackTrace.h"
@@ -298,9 +297,6 @@ namespace {
                                   SILType classType,
                                   bool superclass) {
       for (VarDecl *var : theClass->getStoredProperties()) {
-        if (!var->hasInterfaceType())
-          IGM.Context.getLazyResolver()->resolveDeclSignature(var);
-
         SILType type = classType.getFieldType(var, IGM.getSILModule());
 
         // Lower the field type.

lib/IRGen/GenEnum.cpp

@@ -107,6 +107,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/IRGenOptions.h"
+#include "swift/AST/LazyResolver.h"
 #include "swift/IRGen/Linking.h"
 #include "swift/SIL/SILModule.h"
 #include "llvm/IR/Function.h"
@@ -5778,6 +5779,9 @@ EnumImplStrategy::get(TypeConverter &TC, SILType type, EnumDecl *theEnum) {
       continue;
     }
 
+    if (!elt->hasInterfaceType())
+      TC.IGM.Context.getLazyResolver()->resolveDeclSignature(elt);
+
     // Compute whether this gives us an apparent payload or dynamic layout.
     // Note that we do *not* apply substitutions from a bound generic instance
     // yet. We want all instances of a generic enum to share an implementation

lib/IRGen/GenType.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/CanTypeVisitor.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/LazyResolver.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/Types.h"
@@ -1919,6 +1920,9 @@ namespace {
         return true;
 
       for (auto field : decl->getStoredProperties()) {
+        if (!field->hasInterfaceType())
+          IGM.Context.getLazyResolver()->resolveDeclSignature(field);
+
         if (visit(field->getInterfaceType()->getCanonicalType()))
           return true;
       }
@@ -1940,9 +1944,13 @@ namespace {
         return false;
 
       for (auto elt : decl->getAllElements()) {
-        if (elt->hasAssociatedValues() &&
-            !elt->isIndirect() &&
-            visit(elt->getArgumentInterfaceType()->getCanonicalType()))
+        if (!elt->hasAssociatedValues() || elt->isIndirect())
+          continue;
+
+        if (!elt->hasInterfaceType())
+          IGM.Context.getLazyResolver()->resolveDeclSignature(elt);
+
+        if (visit(elt->getArgumentInterfaceType()->getCanonicalType()))
           return true;
       }
       return false;

lib/SIL/SILType.cpp

@@ -11,10 +11,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SIL/SILType.h"
+#include "swift/AST/ASTMangler.h"
+#include "swift/AST/Decl.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
-#include "swift/AST/ASTMangler.h"
 #include "swift/AST/Type.h"
 #include "swift/SIL/AbstractionPattern.h"
 #include "swift/SIL/SILFunctionConventions.h"
@@ -138,6 +140,9 @@ bool SILType::canRefCast(SILType operTy, SILType resultTy, SILModule &M) {
 SILType SILType::getFieldType(VarDecl *field, SILModule &M) const {
   auto baseTy = getASTType();
 
+  if (!field->hasInterfaceType())
+    field->getASTContext().getLazyResolver()->resolveDeclSignature(field);
+
   AbstractionPattern origFieldTy = M.Types.getAbstractionPattern(field);
   CanType substFieldTy;
   if (field->hasClangNode()) {
@@ -165,6 +170,9 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M) const {
     return SILType(objectType, getCategory());
   }
 
+  if (!elt->hasInterfaceType())
+    elt->getASTContext().getLazyResolver()->resolveDeclSignature(elt);
+
   // If the case is indirect, then the payload is boxed.
   if (elt->isIndirect() || elt->getParentEnum()->isIndirect()) {
     auto box = M.Types.getBoxTypeForEnumElement(*this, elt);

test/multifile/class-layout/final-stored-property/Inputs/library.swift

@@ -1,4 +1,28 @@
-final class Burger {
-  let onions: Bool = true
-  let cheeseSlices: Int = 0
+public struct InnerStruct {
+  let field: Int = 0
+
+  public init() {}
+}
+
+public enum InnerEnum {
+  case field(Int)
+}
+
+public struct OuterStruct {
+  let first: InnerStruct = InnerStruct()
+  let second: InnerEnum = InnerEnum.field(0)
+
+  public init() {}
+}
+
+public final class Burger {
+  public let onions: Bool = true
+  public let complex: OuterStruct = OuterStruct()
+  public let cheeseSlices: Int = 0
+}
+
+@_fixed_layout
+public final class Burrito {
+  public let filling: OuterStruct = OuterStruct()
+  public let cilantro: Int = 0
 }

test/multifile/class-layout/final-stored-property/main.swift

@@ -1,6 +1,13 @@
 // RUN: %target-build-swift %S/Inputs/library.swift %S/main.swift
 // RUN: %target-build-swift -whole-module-optimization %S/Inputs/library.swift %S/main.swift
+// RUN: %target-build-swift -enable-library-evolution %S/Inputs/library.swift %S/main.swift
+// RUN: %target-build-swift -enable-library-evolution -whole-module-optimization %S/Inputs/library.swift %S/main.swift
 
 func meltCheese(_ burger: Burger) -> Int {
   return burger.cheeseSlices
 }
+
+@inlinable
+func bestBurrito(_ burrito: Burrito) -> Int {
+  return burrito.cilantro
+}