---

yaml
---
r: 349297
b: refs/heads/master-next
c: 2ececec
h: refs/heads/master
i:
  349295: b045e29

Author: gottesmm

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 471c7479c7345671b205b743cb51d089abca3a20
+refs/heads/master-next: 2ececec3b5e048da17c47dfd966fb940de887a28
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

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

@@ -1678,7 +1678,11 @@ class ExtensionDecl final : public GenericContext, public Decl,
   TypeRepr *ExtendedTypeRepr;
 
   /// The nominal type being extended.
-  NominalTypeDecl *ExtendedNominal = nullptr;
+  ///
+  /// The bit indicates whether binding has been attempted. The pointer can be
+  /// null if either no binding was attempted or if binding could not find  the
+  /// extended nominal.
+  llvm::PointerIntPair<NominalTypeDecl *, 1, bool> ExtendedNominal;
 
   MutableArrayRef<TypeLoc> Inherited;
 
@@ -1738,6 +1742,12 @@ class ExtensionDecl final : public GenericContext, public Decl,
   SourceRange getBraces() const { return Braces; }
   void setBraces(SourceRange braces) { Braces = braces; }
 
+  bool hasBeenBound() const { return ExtendedNominal.getInt(); }
+
+  void setExtendedNominal(NominalTypeDecl *n) {
+    ExtendedNominal.setPointerAndInt(n, true);
+  }
+
   /// Retrieve the type being extended.
   ///
   /// Only use this entry point when the complete type, as spelled in the source,
@@ -1746,8 +1756,21 @@ class ExtensionDecl final : public GenericContext, public Decl,
   Type getExtendedType() const;
 
   /// Retrieve the nominal type declaration that is being extended.
+  /// Will  trip an assertion if the declaration has not already been computed.
+  /// In order to fail fast when type checking work is attempted
+  /// before extension binding has taken place.
+
   NominalTypeDecl *getExtendedNominal() const;
 
+  /// Compute the nominal type declaration that is being extended.
+  NominalTypeDecl *computeExtendedNominal() const;
+
+  /// \c hasBeenBound means nothing if this extension can never been bound
+  /// because it is not at the top level.
+  bool canNeverBeBound() const;
+
+  bool hasValidParent() const;
+
   /// Determine whether this extension has already been bound to a nominal
   /// type declaration.
   bool alreadyBoundToNominal() const { return NextExtension.getInt(); }

branches/master-next/include/swift/AST/DeclContext.h

@@ -470,6 +470,10 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// AnyObject dynamic lookup.
   bool mayContainMembersAccessedByDynamicLookup() const;
 
+  /// Extensions are only allowed at the level in a file
+  /// FIXME: do this for Protocols, too someday
+  bool canBeParentOfExtension() const;
+
   /// Returns true if lookups within this context could affect downstream files.
   ///
   /// \param functionsAreNonCascading If true, functions are considered non-

branches/master-next/include/swift/Basic/ExternalUnion.h

@@ -433,27 +433,27 @@ struct MembersHelper<> {
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyConstruct(void *self, int index, const void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveConstruct(void *self, int index, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void copyAssignSame(int index, void *self, const void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void moveAssignSame(int index, void *self, void *other) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE
   static void destruct(int index, void *self) {
-    llvm_unreachable("bad index");
+    assert(false && "bad index");
   }
 };
 

branches/master-next/include/swift/Reflection/ReflectionContext.h

@@ -608,14 +608,17 @@ class ReflectionContext
       auto CDAddr = this->readCaptureDescriptorFromMetadata(*MetadataAddress);
       if (!CDAddr)
         return nullptr;
+      if (!CDAddr->isResolved())
+        return nullptr;
 
       // FIXME: Non-generic SIL boxes also use the HeapLocalVariable metadata
       // kind, but with a null capture descriptor right now (see
       // FixedBoxTypeInfoBase::allocate).
       //
       // Non-generic SIL boxes share metadata among types with compatible
       // layout, but we need some way to get an outgoing pointer map for them.
-      auto CD = getBuilder().getCaptureDescriptor(*CDAddr);
+      auto CD = getBuilder().getCaptureDescriptor(
+                                CDAddr->getResolvedAddress().getAddressData());
       if (CD == nullptr)
         return nullptr;
 

branches/master-next/include/swift/Remote/MemoryReader.h

@@ -69,7 +69,7 @@ class MemoryReader {
   /// NOTE: subclasses MUST override at least one of the readBytes functions. The default
   /// implementation calls through to the other one.
   virtual ReadBytesResult
-    readBytes(RemoteAddress address, uint64_t size) {
+  readBytes(RemoteAddress address, uint64_t size) {
     auto *Buf = malloc(size);
     ReadBytesResult Result(Buf, [](const void *ptr) {
       free(const_cast<void *>(ptr));
@@ -96,6 +96,34 @@ class MemoryReader {
     memcpy(dest, Ptr.get(), size);
     return true;
   }
+  
+  /// Attempts to resolve a pointer value read from the given remote address.
+  virtual RemoteAbsolutePointer resolvePointer(RemoteAddress address,
+                                               uint64_t readValue) {
+    // Default implementation returns the read value as is.
+    return RemoteAbsolutePointer("", readValue);
+  }
+  
+  /// Attempt to read and resolve a pointer value at the given remote address.
+  llvm::Optional<RemoteAbsolutePointer> readPointer(RemoteAddress address,
+                                                    unsigned pointerSize) {
+    auto result = readBytes(address, pointerSize);
+    if (!result)
+      return llvm::None;
+    
+    uint64_t pointerData;
+    if (pointerSize == 4) {
+      uint32_t theData;
+      memcpy(&theData, result.get(), 4);
+      pointerData = theData;
+    } else if (pointerSize == 8) {
+      memcpy(&pointerData, result.get(), 8);
+    } else {
+      return llvm::None;
+    }
+    
+    return resolvePointer(address, pointerData);
+  }
 
   virtual ~MemoryReader() = default;
 };