---

yaml
---
r: 348511
b: refs/heads/master
c: 397ff4c
h: refs/heads/master
i:
  348509: b02d40f
  348507: 6027b3f
  348503: aac7f3c
  348495: 0284823
  348479: 9f2f4b7

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: aa7fa85a3734a7d52b622efd5f6efee828061ce9
+refs/heads/master: 397ff4ce051fb2f775fe5a25a9f01ddc68a43798
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/Types.h

@@ -4193,10 +4193,6 @@ class SILBoxType final : public TypeBase, public llvm::FoldingSetNode
   SILLayout *getLayout() const { return Layout; }
   SubstitutionMap getSubstitutions() const { return Substitutions; }
 
-  // In SILType.h:
-  CanType getFieldLoweredType(SILModule &M, unsigned index) const;
-  SILType getFieldType(SILModule &M, unsigned index) const;
-
   // TODO: SILBoxTypes should be explicitly constructed in terms of specific
   // layouts. As a staging mechanism, we expose the old single-boxed-type
   // interface.

trunk/include/swift/Frontend/Frontend.h

@@ -55,6 +55,10 @@ class SerializedModuleLoader;
 class MemoryBufferSerializedModuleLoader;
 class SILModule;
 
+namespace Lowering {
+class TypeConverter;
+}
+
 /// The abstract configuration of the compiler, including:
 ///   - options for all stages of translation,
 ///   - information about the build environment,
@@ -372,6 +376,7 @@ class CompilerInstance {
   SourceManager SourceMgr;
   DiagnosticEngine Diagnostics{SourceMgr};
   std::unique_ptr<ASTContext> Context;
+  std::unique_ptr<Lowering::TypeConverter> TheSILTypes;
   std::unique_ptr<SILModule> TheSILModule;
 
   std::unique_ptr<PersistentParserState> PersistentState;
@@ -422,8 +427,6 @@ class CompilerInstance {
 
   bool isWholeModuleCompilation() { return PrimaryBufferIDs.empty(); }
 
-  void createSILModule();
-
 public:
   // Out of line to avoid having to import SILModule.h.
   CompilerInstance();
@@ -448,6 +451,10 @@ class CompilerInstance {
   SILOptions &getSILOptions() { return Invocation.getSILOptions(); }
   const SILOptions &getSILOptions() const { return Invocation.getSILOptions(); }
 
+  Lowering::TypeConverter &getSILTypes();
+
+  void createSILModule();
+
   void addDiagnosticConsumer(DiagnosticConsumer *DC) {
     Diagnostics.addConsumer(*DC);
   }

trunk/include/swift/SIL/Projection.h

@@ -292,30 +292,7 @@ class Projection {
   ///
   /// WARNING: This is not a constant time operation because it is implemented
   /// in terms of getVarDecl, which requests all BaseType's stored properties.
-  SILType getType(SILType BaseType, SILModule &M) const {
-    assert(isValid());
-    switch (getKind()) {
-    case ProjectionKind::Struct:
-    case ProjectionKind::Class:
-      return BaseType.getFieldType(getVarDecl(BaseType), M);
-    case ProjectionKind::Enum:
-      return BaseType.getEnumElementType(getEnumElementDecl(BaseType), M);
-    case ProjectionKind::Box:
-      return BaseType.castTo<SILBoxType>()->getFieldType(M, getIndex());
-    case ProjectionKind::Tuple:
-      return BaseType.getTupleElementType(getIndex());
-    case ProjectionKind::Upcast:
-    case ProjectionKind::RefCast:
-    case ProjectionKind::BitwiseCast:
-    case ProjectionKind::TailElems:
-      return getCastType(BaseType);
-    case ProjectionKind::Index:
-      // Index types do not change the underlying type.
-      return BaseType;
-    }
-
-    llvm_unreachable("Unhandled ProjectionKind in switch.");
-  }
+  SILType getType(SILType BaseType, SILModule &M) const;
 
   VarDecl *getVarDecl(SILType BaseType) const {
     assert(isValid());

trunk/include/swift/SIL/SILBuilder.h

@@ -1746,13 +1746,7 @@ class SILBuilder {
         getSILDebugLocation(Loc), valueType, operand));
   }
   ProjectBoxInst *createProjectBox(SILLocation Loc, SILValue boxOperand,
-                                   unsigned index) {
-    auto boxTy = boxOperand->getType().castTo<SILBoxType>();
-    auto fieldTy = boxTy->getFieldType(getModule(), index);
-
-    return insert(new (getModule()) ProjectBoxInst(
-        getSILDebugLocation(Loc), boxOperand, index, fieldTy));
-  }
+                                   unsigned index);
   ProjectExistentialBoxInst *createProjectExistentialBox(SILLocation Loc,
                                                          SILType valueTy,
                                                          SILValue boxOperand) {

trunk/include/swift/SIL/SILCloner.h

@@ -2089,7 +2089,7 @@ visitOpenExistentialMetatypeInst(OpenExistentialMetatypeInst *Inst) {
   remapOpenedType(cast<OpenedArchetypeType>(openedType));
 
   if (!Inst->getOperand()->getType().canUseExistentialRepresentation(
-          Inst->getModule(), ExistentialRepresentation::Class)) {
+          ExistentialRepresentation::Class)) {
     getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
     recordClonedInstruction(Inst, getBuilder().createOpenExistentialMetatype(
                                       getOpLocation(Inst->getLoc()),

trunk/include/swift/SIL/SILInstruction.h

@@ -1643,9 +1643,7 @@ class AllocBoxInst final
   bool hasDynamicLifetime() const { return dynamicLifetime; }
 
   // Return the type of the memory stored in the alloc_box.
-  SILType getAddressType() const {
-    return getBoxType()->getFieldType(getModule(), 0).getAddressType();
-  }
+  SILType getAddressType() const;
 
   /// Return the underlying variable declaration associated with this
   /// allocation, or null if this is a temporary allocation.

trunk/include/swift/SIL/SILModule.h

@@ -260,7 +260,8 @@ class SILModule {
 
   // Intentionally marked private so that we need to use 'constructSIL()'
   // to construct a SILModule.
-  SILModule(ModuleDecl *M, SILOptions &Options, const DeclContext *associatedDC,
+  SILModule(ModuleDecl *M, Lowering::TypeConverter &TC,
+            SILOptions &Options, const DeclContext *associatedDC,
             bool wholeModule);
 
   SILModule(const SILModule&) = delete;
@@ -313,7 +314,7 @@ class SILModule {
   void serialize();
 
   /// This converts Swift types to SILTypes.
-  mutable Lowering::TypeConverter Types;
+  Lowering::TypeConverter &Types;
 
   /// Invalidate cached entries in SIL Loader.
   void invalidateSILLoaderCaches();
@@ -340,12 +341,14 @@ class SILModule {
   /// If a source file is provided, SIL will only be emitted for decls in that
   /// source file.
   static std::unique_ptr<SILModule>
-  constructSIL(ModuleDecl *M, SILOptions &Options, FileUnit *sf = nullptr);
+  constructSIL(ModuleDecl *M, Lowering::TypeConverter &TC,
+               SILOptions &Options, FileUnit *sf = nullptr);
 
   /// Create and return an empty SIL module that we can
   /// later parse SIL bodies directly into, without converting from an AST.
   static std::unique_ptr<SILModule>
-  createEmptyModule(ModuleDecl *M, SILOptions &Options,
+  createEmptyModule(ModuleDecl *M, Lowering::TypeConverter &TC,
+                    SILOptions &Options,
                     bool WholeModule = false);
 
   /// Get the Swift module associated with this SIL module.

trunk/include/swift/SIL/SILType.h

@@ -228,26 +228,29 @@ class SILType {
   /// something of unknown size.
   ///
   /// This is equivalent to, but possibly faster than, calling
-  /// M.Types.getTypeLowering(type).isAddressOnly().
-  static bool isAddressOnly(CanType T, SILModule &M,
-                            CanGenericSignature Sig,
-                            ResilienceExpansion Expansion);
+  /// tc.getTypeLowering(type).isAddressOnly().
+  static bool isAddressOnly(CanType type, Lowering::TypeConverter &tc,
+                            CanGenericSignature sig,
+                            ResilienceExpansion expansion);
+
   /// Return true if this type must be returned indirectly.
   ///
   /// This is equivalent to, but possibly faster than, calling
-  /// M.Types.getTypeLowering(type).isReturnedIndirectly().
-  static bool isFormallyReturnedIndirectly(CanType type, SILModule &M,
-                                           CanGenericSignature Sig) {
-    return isAddressOnly(type, M, Sig, ResilienceExpansion::Minimal);
+  /// tc.getTypeLowering(type).isReturnedIndirectly().
+  static bool isFormallyReturnedIndirectly(CanType type,
+                                           Lowering::TypeConverter &tc,
+                                           CanGenericSignature sig) {
+    return isAddressOnly(type, tc, sig, ResilienceExpansion::Minimal);
   }
 
   /// Return true if this type must be passed indirectly.
   ///
   /// This is equivalent to, but possibly faster than, calling
-  /// M.Types.getTypeLowering(type).isPassedIndirectly().
-  static bool isFormallyPassedIndirectly(CanType type, SILModule &M,
-                                         CanGenericSignature Sig) {
-    return isAddressOnly(type, M, Sig, ResilienceExpansion::Minimal);
+  /// tc.getTypeLowering(type).isPassedIndirectly().
+  static bool isFormallyPassedIndirectly(CanType type,
+                                         Lowering::TypeConverter &tc,
+                                         CanGenericSignature sig) {
+    return isAddressOnly(type, tc, sig, ResilienceExpansion::Minimal);
   }
 
   /// True if the type, or the referenced type of an address type, is loadable.
@@ -324,15 +327,13 @@ class SILType {
   /// representation kind for the type. Returns None if the type is not an
   /// existential type.
   ExistentialRepresentation
-  getPreferredExistentialRepresentation(SILModule &M,
-                                        Type containedType = Type()) const;
+  getPreferredExistentialRepresentation(Type containedType = Type()) const;
 
   /// Returns true if the existential type can use operations for the given
   /// existential representation when working with values of the given type,
   /// or when working with an unknown type if containedType is null.
   bool
-  canUseExistentialRepresentation(SILModule &M,
-                                  ExistentialRepresentation repr,
+  canUseExistentialRepresentation(ExistentialRepresentation repr,
                                   Type containedType = Type()) const;
 
   /// True if the type contains a type parameter.
@@ -394,11 +395,15 @@ class SILType {
   /// the given field.  Applies substitutions as necessary.  The
   /// result will be an address type if the base type is an address
   /// type or a class.
+  SILType getFieldType(VarDecl *field, Lowering::TypeConverter &TC) const;
+
   SILType getFieldType(VarDecl *field, SILModule &M) const;
 
   /// Given that this is an enum type, return the lowered type of the
   /// data for the given element.  Applies substitutions as necessary.
   /// The result will have the same value category as the base type.
+  SILType getEnumElementType(EnumElementDecl *elt, Lowering::TypeConverter &TC) const;
+
   SILType getEnumElementType(EnumElementDecl *elt, SILModule &M) const;
 
   /// Given that this is a tuple type, return the lowered type of the
@@ -437,19 +442,29 @@ class SILType {
   /// generic args with the appropriate item from the substitution.
   ///
   /// Only call this with function types!
+  SILType substGenericArgs(Lowering::TypeConverter &TC,
+                           SubstitutionMap SubMap) const;
+
   SILType substGenericArgs(SILModule &M,
                            SubstitutionMap SubMap) const;
 
   /// If the original type is generic, pass the signature as genericSig.
   ///
   /// If the replacement types are generic, you must push a generic context
   /// first.
-  SILType subst(SILModule &silModule, TypeSubstitutionFn subs,
+  SILType subst(Lowering::TypeConverter &tc, TypeSubstitutionFn subs,
                 LookupConformanceFn conformances,
                 CanGenericSignature genericSig = CanGenericSignature(),
                 bool shouldSubstituteOpaqueArchetypes = false) const;
 
-  SILType subst(SILModule &silModule, SubstitutionMap subs) const;
+  SILType subst(SILModule &M, TypeSubstitutionFn subs,
+                LookupConformanceFn conformances,
+                CanGenericSignature genericSig = CanGenericSignature(),
+                bool shouldSubstituteOpaqueArchetypes = false) const;
+
+  SILType subst(Lowering::TypeConverter &tc, SubstitutionMap subs) const;
+
+  SILType subst(SILModule &M, SubstitutionMap subs) const;
 
   /// Return true if this type references a "ref" type that has a single pointer
   /// representation. Class existentials do not always qualify.
@@ -560,7 +575,7 @@ NON_SIL_TYPE(LValue)
 #undef NON_SIL_TYPE
 
 CanSILFunctionType getNativeSILFunctionType(
-    SILModule &M, Lowering::AbstractionPattern origType,
+    Lowering::TypeConverter &TC, Lowering::AbstractionPattern origType,
     CanAnyFunctionType substType,
     Optional<SILDeclRef> origConstant = None,
     Optional<SILDeclRef> constant = None,
@@ -581,17 +596,24 @@ static inline llvm::hash_code hash_value(SILType V) {
   return llvm::hash_value(V.getOpaqueValue());
 }
 
-inline SILType SILBoxType::getFieldType(SILModule &M, unsigned index) const {
-  return SILType::getPrimitiveAddressType(getFieldLoweredType(M, index));
-}
-
 inline SILType SILField::getAddressType() const {
   return SILType::getPrimitiveAddressType(getLoweredType());
 }
 inline SILType SILField::getObjectType() const {
   return SILType::getPrimitiveObjectType(getLoweredType());
 }
 
+CanType getSILBoxFieldLoweredType(SILBoxType *type,
+                                  Lowering::TypeConverter &TC,
+                                  unsigned index);
+
+inline SILType getSILBoxFieldType(SILBoxType *type,
+                                  Lowering::TypeConverter &TC,
+                                  unsigned index) {
+  return SILType::getPrimitiveAddressType(
+    getSILBoxFieldLoweredType(type, TC, index));
+}
+
 } // end swift namespace
 
 namespace llvm {

trunk/include/swift/SIL/TypeLowering.h

@@ -35,6 +35,7 @@ namespace swift {
   class ForeignErrorConvention;
   enum IsInitialization_t : bool;
   enum IsTake_t : bool;
+  class ModuleDecl;
   class SILBuilder;
   class SILLocation;
   class SILModule;
@@ -712,10 +713,10 @@ class TypeConverter {
                               const TypeLowering *lowering);
 
 public:
-  SILModule &M;
+  ModuleDecl &M;
   ASTContext &Context;
 
-  TypeConverter(SILModule &m);
+  TypeConverter(ModuleDecl &m);
   ~TypeConverter();
   TypeConverter(TypeConverter const &) = delete;
   TypeConverter &operator=(TypeConverter const &) = delete;
@@ -803,7 +804,8 @@ class TypeConverter {
   }
 
   SILType getLoweredLoadableType(Type t,
-                                 ResilienceExpansion forExpansion) {
+                                 ResilienceExpansion forExpansion,
+                                 SILModule &M) {
     const TypeLowering &ti = getTypeLowering(t, forExpansion);
     assert(
         (ti.isLoadable() || !SILModuleConventions(M).useLoweredAddresses()) &&

trunk/include/swift/Subsystems.h

@@ -69,6 +69,10 @@ namespace swift {
   class UnifiedStatsReporter;
   enum class SourceFileKind;
 
+  namespace Lowering {
+    class TypeConverter;
+  }
+
   /// Used to optionally maintain SIL parsing context for the parser.
   ///
   /// When not parsing SIL, this has no overhead.
@@ -254,11 +258,13 @@ namespace swift {
   /// The module must contain source files. The optimizer will assume that the
   /// SIL of all files in the module is present in the SILModule.
   std::unique_ptr<SILModule>
-  performSILGeneration(ModuleDecl *M, SILOptions &options);
+  performSILGeneration(ModuleDecl *M, Lowering::TypeConverter &TC,
+                       SILOptions &options);
 
   /// Turn a source file into SIL IR.
   std::unique_ptr<SILModule>
-  performSILGeneration(FileUnit &SF, SILOptions &options);
+  performSILGeneration(FileUnit &SF, Lowering::TypeConverter &TC,
+                       SILOptions &options);
 
   using ModuleOrSourceFile = PointerUnion<ModuleDecl *, SourceFile *>;
 

trunk/lib/Frontend/Frontend.cpp

@@ -148,11 +148,20 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
   return serializationOpts;
 }
 
+Lowering::TypeConverter &CompilerInstance::getSILTypes() {
+  if (auto *tc = TheSILTypes.get())
+    return *tc;
+  
+  auto *tc = new Lowering::TypeConverter(*getMainModule());
+  TheSILTypes.reset(tc);
+  return *tc;
+}
+
 void CompilerInstance::createSILModule() {
   assert(MainModule && "main module not created yet");
   // Assume WMO if a -primary-file option was not provided.
   TheSILModule = SILModule::createEmptyModule(
-      getMainModule(), Invocation.getSILOptions(),
+      getMainModule(), getSILTypes(), Invocation.getSILOptions(),
       Invocation.getFrontendOptions().InputsAndOutputs.isWholeModule());
 }
 
@@ -1071,6 +1080,7 @@ void CompilerInstance::performParseOnly(bool EvaluateConditionals,
 
 void CompilerInstance::freeASTContext() {
   PersistentState.reset();
+  TheSILTypes.reset();
   Context.reset();
   MainModule = nullptr;
   SML = nullptr;