Change SIL ref_element_addr getFieldNo() to return a unique index.

I don't have a test case for this bug based on the current code. But
the fix is clearly needed to have a unique AccessStorage object for
each property. The AccessPath commits will contain test cases for this
functionality.

Author: atrick

include/swift/SIL/Projection.h

@@ -302,10 +302,9 @@ class Projection {
     assert(isValid());
     assert((getKind() == ProjectionKind::Struct ||
             getKind() == ProjectionKind::Class));
-    assert(BaseType.getNominalOrBoundGenericNominal() &&
-           "This should only be called with a nominal type");
-    auto *NDecl = BaseType.getNominalOrBoundGenericNominal();
-    return NDecl->getStoredProperties()[getIndex()];
+    auto *nominalDecl = BaseType.getNominalOrBoundGenericNominal();
+    assert(nominalDecl && "This should only be called with a nominal type");
+    return getIndexedField(nominalDecl, getIndex());
   }
 
   EnumElementDecl *getEnumElementDecl(SILType BaseType) const {

include/swift/SIL/SILInstruction.h

@@ -5757,6 +5757,26 @@ class TupleElementAddrInst
   }
 };
 
+/// Get a unique index for a struct or class field in layout order.
+///
+/// Precondition: \p decl must be a non-resilient struct or class.
+///
+/// Precondition: \p field must be a stored property declared in \p decl,
+///               not in a superclass.
+///
+/// Postcondition: The returned index is unique across all properties in the
+///                object, including properties declared in a superclass.
+unsigned getFieldIndex(NominalTypeDecl *decl, VarDecl *property);
+
+/// Get the property for a struct or class by its unique index.
+///
+/// Precondition: \p decl must be a non-resilient struct or class.
+///
+/// Precondition: \p index must be the index of a stored property
+///               (as returned by getFieldIndex()) which is declared
+///               in \p decl, not in a superclass.
+VarDecl *getIndexedField(NominalTypeDecl *decl, unsigned index);
+
 /// A common base for instructions that require a cached field index.
 ///
 /// "Field" is a term used here to refer to the ordered, accessible stored

lib/SIL/IR/SILInstructions.cpp

@@ -1323,18 +1323,43 @@ bool TupleExtractInst::isEltOnlyNonTrivialElt() const {
   return true;
 }
 
-unsigned FieldIndexCacheBase::cacheFieldIndex() {
-  unsigned i = 0;
-  for (VarDecl *property : getParentDecl()->getStoredProperties()) {
+/// Get a unique index for a struct or class field in layout order.
+unsigned swift::getFieldIndex(NominalTypeDecl *decl, VarDecl *field) {
+  unsigned index = 0;
+  if (auto *classDecl = dyn_cast<ClassDecl>(decl)) {
+    for (auto *superDecl = classDecl->getSuperclassDecl(); superDecl != nullptr;
+         superDecl = superDecl->getSuperclassDecl()) {
+      index += superDecl->getStoredProperties().size();
+    }
+  }
+  for (VarDecl *property : decl->getStoredProperties()) {
     if (field == property) {
-      SILInstruction::Bits.FieldIndexCacheBase.FieldIndex = i;
-      return i;
+      return index;
     }
-    ++i;
+    ++index;
   }
   llvm_unreachable("The field decl for a struct_extract, struct_element_addr, "
-                   "or ref_element_addr must be an accessible stored property "
-                   "of the operand's type");
+                   "or ref_element_addr must be an accessible stored "
+                   "property of the operand type");
+}
+
+/// Get the property for a struct or class by its unique index.
+VarDecl *swift::getIndexedField(NominalTypeDecl *decl, unsigned index) {
+  if (auto *classDecl = dyn_cast<ClassDecl>(decl)) {
+    for (auto *superDecl = classDecl->getSuperclassDecl(); superDecl != nullptr;
+         superDecl = superDecl->getSuperclassDecl()) {
+      assert(index > superDecl->getStoredProperties().size()
+             && "field index cannot refer to a superclass field");
+      index -= superDecl->getStoredProperties().size();
+    }
+  }
+  return decl->getStoredProperties()[index];
+}
+
+unsigned FieldIndexCacheBase::cacheFieldIndex() {
+  unsigned index = getFieldIndex(getParentDecl(), getField());
+  SILInstruction::Bits.FieldIndexCacheBase.FieldIndex = index;
+  return index;
 }
 
 // FIXME: this should be cached during cacheFieldIndex().

lib/SIL/Utils/MemAccessUtils.cpp

@@ -156,7 +156,7 @@ const ValueDecl *AccessedStorage::getDecl() const {
 
   case Class: {
     auto *decl = getObject()->getType().getNominalOrBoundGenericNominal();
-    return decl->getStoredProperties()[getPropertyIndex()];
+    return getIndexedField(decl, getPropertyIndex());
   }
   case Tail:
     return nullptr;

lib/SIL/Utils/Projection.cpp

@@ -321,6 +321,10 @@ void Projection::getFirstLevelProjections(
 
   if (auto *C = Ty.getClassOrBoundGenericClass()) {
     unsigned Count = 0;
+    for (auto *superDecl = C->getSuperclassDecl(); superDecl != nullptr;
+         superDecl = superDecl->getSuperclassDecl()) {
+      Count += superDecl->getStoredProperties().size();
+    }
     for (auto *VDecl : C->getStoredProperties()) {
       (void) VDecl;
       Projection P(ProjectionKind::Class, Count++);