---

yaml
---
r: 319341
b: refs/heads/master-rebranch
c: 33ee4a4
h: refs/heads/master
i:
  319339: 49a8ade

Author: swift-ci

[refs]

@@ -1457,4 +1457,4 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: 3d34789f6b64964fe5cf4fc9c60e0dab9fc54c4a
+refs/heads/master-rebranch: 33ee4a44303c5de97df9561be6778c5cf58a87ae

branches/master-rebranch/include/swift/AST/Decl.h

@@ -3045,17 +3045,19 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
   SourceLoc KeywordLoc;
 
   /// The default definition.
-  TypeLoc DefaultDefinition;
+  TypeRepr *DefaultDefinition;
 
   /// The where clause attached to the associated type.
   TrailingWhereClause *TrailingWhere;
 
   LazyMemberLoader *Resolver = nullptr;
   uint64_t ResolverContextData;
 
+  friend class DefaultDefinitionTypeRequest;
+
 public:
   AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc, Identifier name,
-                     SourceLoc nameLoc, TypeLoc defaultDefinition,
+                     SourceLoc nameLoc, TypeRepr *defaultDefinition,
                      TrailingWhereClause *trailingWhere);
   AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc, Identifier name,
                      SourceLoc nameLoc, TrailingWhereClause *trailingWhere,
@@ -3071,17 +3073,14 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
   bool hasDefaultDefinitionType() const {
     // If we have a TypeRepr, return true immediately without kicking off
     // a request.
-    return !DefaultDefinition.isNull() || getDefaultDefinitionType();
+    return DefaultDefinition || getDefaultDefinitionType();
   }
 
   /// Retrieve the default definition type.
   Type getDefaultDefinitionType() const;
 
-  TypeLoc &getDefaultDefinitionLoc() {
-    return DefaultDefinition;
-  }
-
-  const TypeLoc &getDefaultDefinitionLoc() const {
+  /// Retrieve the default definition as written in the source.
+  TypeRepr *getDefaultDefinitionTypeRepr() const {
     return DefaultDefinition;
   }
 

branches/master-rebranch/include/swift/AST/TypeCheckRequests.h

@@ -269,6 +269,30 @@ class RequirementSignatureRequest :
   void cacheResult(ArrayRef<Requirement> value) const;
 };
 
+/// Compute the default definition type of an associated type.
+class DefaultDefinitionTypeRequest :
+    public SimpleRequest<DefaultDefinitionTypeRequest,
+                         CacheKind::Cached,
+                         Type,
+                         AssociatedTypeDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<Type> evaluate(Evaluator &evaluator, AssociatedTypeDecl *decl) const;
+
+public:
+  // Cycle handling
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 /// Describes the owner of a where clause, from which we can extract
 /// requirements.
 struct WhereClauseOwner {

branches/master-rebranch/include/swift/AST/TypeCheckerTypeIDZone.def

@@ -23,6 +23,7 @@ SWIFT_TYPEID(IsFinalRequest)
 SWIFT_TYPEID(IsDynamicRequest)
 SWIFT_TYPEID(RequirementRequest)
 SWIFT_TYPEID(RequirementSignatureRequest)
+SWIFT_TYPEID(DefaultDefinitionTypeRequest)
 SWIFT_TYPEID(USRGenerationRequest)
 SWIFT_TYPEID(StructuralTypeRequest)
 SWIFT_TYPEID(DefaultTypeRequest)

branches/master-rebranch/include/swift/SIL/MemAccessUtils.h

@@ -15,8 +15,9 @@
 #ifndef SWIFT_SIL_MEMACCESSUTILS_H
 #define SWIFT_SIL_MEMACCESSUTILS_H
 
-#include "swift/SIL/Projection.h"
 #include "swift/SIL/InstructionUtils.h"
+#include "swift/SIL/SILArgument.h"
+#include "swift/SIL/SILBasicBlock.h"
 #include "swift/SIL/SILInstruction.h"
 #include "llvm/ADT/DenseMap.h"
 
@@ -28,31 +29,6 @@ inline bool accessKindMayConflict(SILAccessKind a, SILAccessKind b) {
   return !(a == SILAccessKind::Read && b == SILAccessKind::Read);
 }
 
-/// Represents the identity of a stored class property as a combination
-/// of a base and projection.
-class ObjectProjection {
-  SILValue object;
-  Projection proj;
-
-public:
-  ObjectProjection(SILValue object, const Projection &projection)
-      : object(object), proj(projection) {
-    assert(object->getType().isObject());
-  }
-
-  SILValue getObject() const { return object; }
-
-  const Projection &getProjection() const { return proj; }
-
-  bool operator==(const ObjectProjection &other) const {
-    return object == other.object && proj == other.proj;
-  }
-
-  bool operator!=(const ObjectProjection &other) const {
-    return object != other.object || proj != other.proj;
-  }
-};
-
 /// Represents the identity of a storage object being accessed.
 ///
 /// AccessedStorage may be one of several kinds of "identified" storage
@@ -107,7 +83,23 @@ class AccessedStorage {
   /// of access base. Otherwise, return Unidentified.
   static AccessedStorage::Kind classify(SILValue base);
 
+  /// Directly create an AccessedStorage for class property access.
+  static AccessedStorage forClass(SILValue object, unsigned propertyIndex) {
+    AccessedStorage storage;
+    storage.initKind(Class, propertyIndex);
+    storage.value = object;
+    return storage;
+  }
+
 protected:
+  // Checking the storage kind is far more common than other fields. Make sure
+  // it can be byte load with no shift.
+  static const int ReservedKindBits = 8;
+  static_assert(ReservedKindBits >= NumKindBits, "Too many storage kinds.");
+
+  static const unsigned InvalidElementIndex =
+      (1 << (32 - ReservedKindBits)) - 1;
+
   // Form a bitfield that is effectively a union over any pass-specific data
   // with the fields used within this class as a common prefix.
   //
@@ -122,9 +114,13 @@ class AccessedStorage {
   // each begin_access to its storage object, unique access index, and summary
   // info for that access.
   union {
-    uint64_t OpaqueBits;
-    SWIFT_INLINE_BITFIELD_BASE(AccessedStorage, bitmax(NumKindBits, 8),
-                               Kind : bitmax(NumKindBits, 8));
+    uint64_t opaqueBits;
+    // elementIndex can overflow while gracefully degrading analysis. For now,
+    // reserve an absurd number of bits at a nice alignment boundary, but this
+    // can be reduced.
+    SWIFT_INLINE_BITFIELD_BASE(AccessedStorage, 32, kind
+                               : ReservedKindBits,
+                                 elementIndex : 32 - ReservedKindBits);
 
     // Define bits for use in AccessedStorageAnalysis. Each identified storage
     // object is mapped to one instance of this subclass.
@@ -157,59 +153,67 @@ class AccessedStorage {
 
 private:
   union {
+    // For non-class storage, 'value' is the access base. For class storage
+    // 'value' is the object base, where the access base is the class' stored
+    // property.
     SILValue value;
-    unsigned paramIndex;
     SILGlobalVariable *global;
-    ObjectProjection objProj;
   };
 
-  void initKind(Kind k) {
-    Bits.OpaqueBits = 0;
-    Bits.AccessedStorage.Kind = k;
+  void initKind(Kind k, unsigned elementIndex = InvalidElementIndex) {
+    Bits.opaqueBits = 0;
+    Bits.AccessedStorage.kind = k;
+    Bits.AccessedStorage.elementIndex = elementIndex;
+  }
+
+  unsigned getElementIndex() const { return Bits.AccessedStorage.elementIndex; }
+  void setElementIndex(unsigned elementIndex) {
+    Bits.AccessedStorage.elementIndex = elementIndex;
   }
 
 public:
   AccessedStorage() : value() { initKind(Unidentified); }
 
   AccessedStorage(SILValue base, Kind kind);
 
-  AccessedStorage(SILValue object, Projection projection)
-      : objProj(object, projection) {
-    initKind(Class);
-  }
-
   // Return true if this is a valid storage object.
   operator bool() const { return getKind() != Unidentified || value; }
 
-  Kind getKind() const { return static_cast<Kind>(Bits.AccessedStorage.Kind); }
+  Kind getKind() const { return static_cast<Kind>(Bits.AccessedStorage.kind); }
 
   // Clear any bits reserved for subclass data. Useful for up-casting back to
   // the base class.
-  void resetSubclassData() { initKind(getKind()); }
+  void resetSubclassData() {
+    initKind(getKind(), Bits.AccessedStorage.elementIndex);
+  }
 
   SILValue getValue() const {
-    assert(getKind() != Argument && getKind() != Global && getKind() != Class);
+    assert(getKind() != Global && getKind() != Class);
     return value;
   }
 
   unsigned getParamIndex() const {
     assert(getKind() == Argument);
-    return paramIndex;
+    return getElementIndex();
   }
 
-  SILArgument *getArgument(SILFunction *F) const {
+  SILArgument *getArgument() const {
     assert(getKind() == Argument);
-    return F->getArgument(paramIndex);
+    return cast<SILArgument>(value);
   }
 
   SILGlobalVariable *getGlobal() const {
     assert(getKind() == Global);
     return global;
   }
 
-  const ObjectProjection &getObjectProjection() const {
+  SILValue getObject() const {
     assert(getKind() == Class);
-    return objProj;
+    return value;
+  }
+  unsigned getPropertyIndex() const {
+    assert(getKind() == Class);
+    return getElementIndex();
   }
 
   /// Return true if the given storage objects have identical storage locations.
@@ -223,16 +227,16 @@ class AccessedStorage {
     switch (getKind()) {
     case Box:
     case Stack:
+    case Argument:
     case Yield:
     case Nested:
     case Unidentified:
       return value == other.value;
-    case Argument:
-      return paramIndex == other.paramIndex;
     case Global:
       return global == other.global;
     case Class:
-      return objProj == other.objProj;
+      return value == other.value
+             && getElementIndex() == other.getElementIndex();
     }
   }
 
@@ -286,19 +290,19 @@ class AccessedStorage {
     // Classes are not uniquely identified by their base. However, if the
     // underling objects have identical types and distinct property indices then
     // they are distinct storage locations.
-    auto &proj = getObjectProjection();
-    auto &otherProj = other.getObjectProjection();
-    if (proj.getObject()->getType() == otherProj.getObject()->getType()
-        && proj.getProjection() != otherProj.getProjection()) {
+    if (getObject()->getType() == other.getObject()->getType()
+        && getPropertyIndex() != other.getPropertyIndex()) {
       return true;
     }
     return false;
   }
 
   /// Returns the ValueDecl for the underlying storage, if it can be
-  /// determined. Otherwise returns null. For diagnostics and checking via the
-  /// ValueDecl if we are processing a `let` variable.
-  const ValueDecl *getDecl(SILFunction *F) const;
+  /// determined. Otherwise returns null.
+  ///
+  /// WARNING: This is not a constant-time operation. It is for diagnostics and
+  /// checking via the ValueDecl if we are processing a `let` variable.
+  const ValueDecl *getDecl() const;
 
   void print(raw_ostream &os) const;
   void dump() const;
@@ -343,8 +347,8 @@ template <> struct DenseMapInfo<swift::AccessedStorage> {
     case swift::AccessedStorage::Global:
       return DenseMapInfo<void *>::getHashValue(storage.getGlobal());
     case swift::AccessedStorage::Class: {
-      const swift::ObjectProjection &P = storage.getObjectProjection();
-      return llvm::hash_combine(P.getObject(), P.getProjection());
+      return llvm::hash_combine(storage.getObject(),
+                                storage.getPropertyIndex());
     }
     }
     llvm_unreachable("Unhandled AccessedStorageKind");

branches/master-rebranch/lib/AST/Decl.cpp

@@ -3539,7 +3539,7 @@ SourceRange GenericTypeParamDecl::getSourceRange() const {
 
 AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        Identifier name, SourceLoc nameLoc,
-                                       TypeLoc defaultDefinition,
+                                       TypeRepr *defaultDefinition,
                                        TrailingWhereClause *trailingWhere)
     : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
       KeywordLoc(keywordLoc), DefaultDefinition(defaultDefinition),
@@ -3552,8 +3552,9 @@ AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        LazyMemberLoader *definitionResolver,
                                        uint64_t resolverData)
     : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
-      KeywordLoc(keywordLoc), TrailingWhere(trailingWhere),
-      Resolver(definitionResolver), ResolverContextData(resolverData) {
+      KeywordLoc(keywordLoc), DefaultDefinition(nullptr),
+      TrailingWhere(trailingWhere), Resolver(definitionResolver),
+      ResolverContextData(resolverData) {
   assert(Resolver && "missing resolver");
 }
 
@@ -3566,21 +3567,17 @@ void AssociatedTypeDecl::computeType() {
 }
 
 Type AssociatedTypeDecl::getDefaultDefinitionType() const {
-  if (Resolver) {
-    const_cast<AssociatedTypeDecl *>(this)->DefaultDefinition
-      = TypeLoc::withoutLoc(
-        Resolver->loadAssociatedTypeDefault(this, ResolverContextData));
-    const_cast<AssociatedTypeDecl *>(this)->Resolver = nullptr;
-  }
-  return DefaultDefinition.getType();
+  return evaluateOrDefault(getASTContext().evaluator,
+           DefaultDefinitionTypeRequest{const_cast<AssociatedTypeDecl *>(this)},
+           Type());
 }
 
 SourceRange AssociatedTypeDecl::getSourceRange() const {
   SourceLoc endLoc;
   if (auto TWC = getTrailingWhereClause()) {
     endLoc = TWC->getSourceRange().End;
-  } else if (getDefaultDefinitionLoc().hasLocation()) {
-    endLoc = getDefaultDefinitionLoc().getSourceRange().End;
+  } else if (auto defaultDefinition = getDefaultDefinitionTypeRepr()) {
+    endLoc = defaultDefinition->getEndLoc();
   } else if (!getInherited().empty()) {
     endLoc = getInherited().back().getSourceRange().End;
   } else {

branches/master-rebranch/lib/AST/TypeCheckRequests.cpp

@@ -311,6 +311,20 @@ void RequirementSignatureRequest::cacheResult(ArrayRef<Requirement> value) const
   proto->setRequirementSignature(value);
 }
 
+//----------------------------------------------------------------------------//
+// DefaultDefinitionTypeRequest computation.
+//----------------------------------------------------------------------------//
+
+void DefaultDefinitionTypeRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  auto decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::circular_reference);
+}
+
+void DefaultDefinitionTypeRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  auto decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::circular_reference_through);
+}
+
 //----------------------------------------------------------------------------//
 // Requirement computation.
 //----------------------------------------------------------------------------//