SILOptimizer: Remove isSimpleType()

This was checking if the type is a trivial type that is not a
class. However this was redundant because class types are not
trivial anyway.

Author: slavapestov

include/swift/SILOptimizer/Utils/Local.h

@@ -522,11 +522,6 @@ bool simplifyUsers(SingleValueInstruction *I);
 /// without a significant increase to code size.
 bool shouldExpand(SILModule &Module, SILType Ty);
 
-/// Check if a given type is a simple type, i.e. a builtin
-/// integer or floating point type or a struct/tuple whose members
-/// are of simple types.
-bool isSimpleType(SILType SILTy, SILModule& Module);
-
 /// Check if the value of V is computed by means of a simple initialization.
 /// Store the actual SILValue into \p Val and the reversed list of instructions
 /// initializing it in \p Insns.

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -816,7 +816,7 @@ void SILGlobalOpt::collectGlobalAccess(GlobalAddrInst *GAI) {
   if (GlobalVarSkipProcessing.count(SILG))
     return;
 
-  if (!isSimpleType(SILG->getLoweredType(), *Module)) {
+  if (!SILG->getLoweredType().isTrivial(*Module)) {
     GlobalVarSkipProcessing.insert(SILG);
     return;
   }

lib/SILOptimizer/IPO/LetPropertiesOpts.cpp

@@ -372,7 +372,11 @@ bool LetPropertiesOpt::isConstantLetProperty(VarDecl *Property) {
                           << "' has no unknown uses\n");
 
   // Only properties of simple types can be optimized.
-  if (!isSimpleType(Module->Types.getLoweredType(Property->getType()), *Module)) {
+
+  // FIXME: Expansion
+  auto &TL = Module->Types.getTypeLowering(Property->getType(),
+                                           ResilienceExpansion::Minimal);
+  if (!TL.isTrivial()) {
      LLVM_DEBUG(llvm::dbgs() << "Property '" << *Property
                              << "' is not of trivial type\n");
     SkipProcessing.insert(Property);

lib/SILOptimizer/Utils/Local.cpp

@@ -1518,22 +1518,6 @@ bool swift::shouldExpand(SILModule &Module, SILType Ty) {
 
 /// Some support functions for the global-opt and let-properties-opts
 
-/// Check if a given type is a simple type, i.e. a builtin
-/// integer or floating point type or a struct/tuple whose members
-/// are of simple types.
-/// TODO: Cache the "simple" flag for types to avoid repeating checks.
-bool swift::isSimpleType(SILType SILTy, SILModule& Module) {
-  // Classes can never be initialized statically at compile-time.
-  if (SILTy.getClassOrBoundGenericClass()) {
-    return false;
-  }
-
-  if (!SILTy.isTrivial(Module))
-    return false;
-
-  return true;
-}
-
 // Encapsulate the state used for recursive analysis of a static
 // initializer. Discover all the instruction in a use-def graph and return them
 // in topological order.
@@ -1583,7 +1567,7 @@ class StaticInitializerAnalysis {
   bool recursivelyAnalyzeInstruction(SILInstruction *I) {
     if (auto *SI = dyn_cast<StructInst>(I)) {
       // If it is not a struct which is a simple type, bail.
-      if (!isSimpleType(SI->getType(), SI->getModule()))
+      if (!SI->getType().isTrivial(SI->getModule()))
         return false;
 
       return llvm::all_of(SI->getAllOperands(), [&](Operand &Op) -> bool {
@@ -1592,7 +1576,7 @@ class StaticInitializerAnalysis {
     }
     if (auto *TI = dyn_cast<TupleInst>(I)) {
       // If it is not a tuple which is a simple type, bail.
-      if (!isSimpleType(TI->getType(), TI->getModule()))
+      if (!TI->getType().isTrivial(TI->getModule()))
         return false;
 
       return llvm::all_of(TI->getAllOperands(), [&](Operand &Op) -> bool {