[TypeLowering] Verify lexical property.

Check that if a type is non-trivial then either (1) it is lexical or (2)
its non-trivial leaves are @_eagerMove.

Author: nate-chandler

include/swift/SIL/SILType.h

@@ -753,6 +753,25 @@ class SILType {
   void dump() const;
   void print(raw_ostream &OS,
              const PrintOptions &PO = PrintOptions::printSIL()) const;
+
+#ifndef NDEBUG
+  /// Visit the distinct types of the fields out of which a type is aggregated.
+  ///
+  /// As we walk into the field types, if an aggregate is encountered, it may
+  /// still be a leaf.  It is a leaf if the \p isLeafAggregate predicate
+  /// returns true.
+  ///
+  /// Returns false if the leaves cannot be visited or if any invocation of the
+  /// visitor returns false.
+  ///
+  /// NOTE: This function is meant for use in verification.  For real use-cases,
+  ///       recursive walks of type leaves should be done via
+  ///       TypeLowering::RecursiveProperties.
+  bool visitAggregateLeaves(
+      Lowering::TypeConverter &TC, TypeExpansionContext context,
+      std::function<bool(SILType, SILType, VarDecl *)> isLeafAggregate,
+      std::function<bool(SILType, SILType, VarDecl *)> visit) const;
+#endif
 };
 
 // Statically prevent SILTypes from being directly cast to a type

include/swift/SIL/TypeLowering.h

@@ -1245,6 +1245,12 @@ class TypeConverter {
                                CanType result,
                                Bridgeability bridging,
                                bool suppressOptional);
+#ifndef NDEBUG
+  /// Check the result of
+  /// getTypeLowering(AbstractionPattern,Type,TypeExpansionContext).
+  void verifyLowering(const TypeLowering &, AbstractionPattern origType,
+                      Type origSubstType, TypeExpansionContext forExpansion);
+#endif
 };
 
 } // namespace Lowering

lib/SIL/IR/SILType.cpp

@@ -22,6 +22,7 @@
 #include "swift/SIL/SILFunctionConventions.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/TypeLowering.h"
+#include <tuple>
 
 using namespace swift;
 using namespace swift::Lowering;
@@ -941,3 +942,66 @@ bool SILType::isMoveOnly() const {
       return true;
   return isMoveOnlyWrapped();
 }
+
+#ifndef NDEBUG
+bool SILType::visitAggregateLeaves(
+    Lowering::TypeConverter &TC, TypeExpansionContext context,
+    std::function<bool(SILType, SILType, VarDecl *)> isLeaf,
+    std::function<bool(SILType, SILType, VarDecl *)> visit) const {
+
+  llvm::SmallSet<std::tuple<SILType::ValueType, SILType::ValueType, VarDecl *>,
+                 16>
+      visited;
+  llvm::SmallVector<
+      std::tuple<SILType::ValueType, SILType::ValueType, VarDecl *>, 16>
+      worklist;
+  auto insertIntoWorklist = [&visited, &worklist](SILType parent, SILType type,
+                                                  VarDecl *decl) -> bool {
+    if (!visited.insert({parent.value, type.value, decl}).second) {
+      return false;
+    }
+    worklist.push_back({parent.value, type.value, decl});
+    return true;
+  };
+  auto popFromWorklist =
+      [&worklist]() -> std::tuple<SILType, SILType, VarDecl *> {
+    SILType::ValueType parentOpaqueType;
+    SILType::ValueType opaqueType;
+    VarDecl *decl;
+    std::tie(parentOpaqueType, opaqueType, decl) = worklist.pop_back_val();
+    return {parentOpaqueType, opaqueType, decl};
+  };
+  insertIntoWorklist(SILType(), *this, nullptr);
+  while (!worklist.empty()) {
+    SILType parent;
+    SILType ty;
+    VarDecl *decl;
+    std::tie(parent, ty, decl) = popFromWorklist();
+    if (ty.isAggregate() && !isLeaf(parent, ty, decl)) {
+      if (auto tupleTy = ty.getAs<TupleType>()) {
+        for (unsigned index = 0, num = tupleTy->getNumElements(); index < num;
+             ++index) {
+          insertIntoWorklist(ty, ty.getTupleElementType(index), nullptr);
+        }
+      } else if (auto *decl = ty.getStructOrBoundGenericStruct()) {
+        for (auto *field : decl->getStoredProperties()) {
+          insertIntoWorklist(ty, ty.getFieldType(field, TC, context), field);
+        }
+      } else if (auto *decl = ty.getEnumOrBoundGenericEnum()) {
+        for (auto *field : decl->getStoredProperties()) {
+          insertIntoWorklist(ty, ty.getFieldType(field, TC, context), field);
+        }
+      } else {
+        llvm_unreachable("unknown aggregate kind!");
+      }
+      continue;
+    }
+
+    // This type is a leaf.  Visit it.
+    auto success = visit(parent, ty, decl);
+    if (!success)
+      return false;
+  }
+  return true;
+}
+#endif

lib/SIL/IR/TypeLowering.cpp

@@ -2420,9 +2420,105 @@ TypeConverter::getTypeLowering(AbstractionPattern origType,
     removeNullEntry(key.getKeyForMinimalExpansion());
 #endif
   }
+
+#ifndef NDEBUG
+  verifyLowering(*lowering, origType, origSubstType, forExpansion);
+#endif
+
   return *lowering;
 }
 
+#ifndef NDEBUG
+void TypeConverter::verifyLowering(const TypeLowering &lowering,
+                                   AbstractionPattern origType,
+                                   Type origSubstType,
+                                   TypeExpansionContext forExpansion) {
+  // Non-trivial lowerings should always be lexical unless all non-trivial
+  // fields are eager move.
+  if (!lowering.isTrivial() && !lowering.isLexical()) {
+    auto getLifetimeAnnotation = [](SILType ty) -> LifetimeAnnotation {
+      NominalTypeDecl *nominal;
+      if (!(nominal = ty.getASTType().getAnyNominal()))
+        return LifetimeAnnotation::None;
+      return nominal->getLifetimeAnnotation();
+    };
+    auto loweredType = lowering.getLoweredType();
+    bool hasNoNontrivialLexicalLeaf = loweredType.visitAggregateLeaves(
+        *this, forExpansion,
+        /*isLeaf=*/
+        [&](auto parent, auto ty, auto *fieldDecl) -> bool {
+          // The field's type is an aggregate.  Treat it as a leaf if it
+          // has a lifetime annotation.
+
+          // If we don't have a field decl, it's either a field of a tuple
+          // or the top-level type.  Either way, there's no var decl on
+          // which to look for an attribute.
+          //
+          // It's a leaf if the type has a lifetime annotation.
+          if (!fieldDecl)
+            return getLifetimeAnnotation(ty).isSome();
+
+          // It's a field of a struct or an enum.  It's a leaf if the type
+          // or the var decl has a lifetime annotation.
+          return fieldDecl->getLifetimeAnnotation().isSome() ||
+                 getLifetimeAnnotation(ty);
+        },
+        /*visit=*/
+        [&](auto parent, auto ty, auto *fieldDecl) -> bool {
+          // Look at each leaf: if it is non-trivial, verify that it is
+          // attributed @_eagerMove.
+
+          // If the leaf is the whole type, verify that it is annotated
+          // @_eagerMove.
+          if (ty == loweredType)
+            return getLifetimeAnnotation(ty) == LifetimeAnnotation::EagerMove;
+
+          // Get ty's lowering.
+          CanGenericSignature sig;
+          if (fieldDecl) {
+            AbstractionPattern origFieldTy = getAbstractionPattern(fieldDecl);
+            CanType substFieldTy;
+            if (fieldDecl->hasClangNode()) {
+              substFieldTy = origFieldTy.getType();
+            } else {
+              substFieldTy = parent.getASTType()
+                                 ->getTypeOfMember(&M, fieldDecl)
+                                 ->getCanonicalType();
+            }
+            sig = getAbstractionPattern(fieldDecl).getGenericSignatureOrNull();
+          } else {
+            sig = CanGenericSignature();
+          }
+          auto &tyLowering = getTypeLowering(ty, forExpansion, sig);
+
+          // Leaves which are trivial aren't of interest.
+          if (tyLowering.isTrivial())
+            return true;
+
+          // We're visiting a non-trival leaf of a type whose lowering is
+          // not lexical.  The leaf must be annotated @_eagerMove.
+          // Otherwise, the whole type would be lexical.
+
+          if (!fieldDecl) {
+            // The field is non-trivial and the whole type is non-lexical.
+            // If there's no field decl which might be annotated
+            // @_eagerMove, we have a problem.
+            return false;
+          }
+
+          // The field is non-trivial and the whole type is non-lexical.
+          // That's fine as long as the field or its type is annotated
+          // @_eagerMove.
+          return fieldDecl->getLifetimeAnnotation() ==
+                     LifetimeAnnotation::EagerMove ||
+                 getLifetimeAnnotation(ty) == LifetimeAnnotation::EagerMove;
+        });
+    assert(hasNoNontrivialLexicalLeaf &&
+           "Found non-trivial lexical leaf in non-trivial non-lexical type?!");
+  }
+}
+#endif
+
 CanType
 TypeConverter::computeLoweredRValueType(TypeExpansionContext forExpansion,
                                         AbstractionPattern origType,