Merge branch 'main' into rhombicuboctahedron

Author: jckarter

lib/AST/ConformanceLookupTable.cpp

@@ -862,8 +862,6 @@ DeclContext *ConformanceLookupTable::getConformingContext(
       Type classTy = nominal->getDeclaredInterfaceType();
       do {
         Type superclassTy = classTy->getSuperclassForDecl(superclassDecl);
-        if (superclassTy->is<ErrorType>())
-          return nullptr;
         auto inheritedConformance = swift::lookupConformance(
             superclassTy, protocol, /*allowMissing=*/false);
         if (inheritedConformance)
@@ -936,8 +934,6 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
     // declared.
     auto *conformingClass = cast<ClassDecl>(conformingNominal);
     Type superclassTy = type->getSuperclassForDecl(conformingClass);
-    if (superclassTy->is<ErrorType>())
-      return nullptr;
 
     // Look up the inherited conformance.
     auto inheritedConformance = swift::lookupConformance(

lib/AST/RequirementMachine/Symbol.cpp

@@ -366,6 +366,8 @@ Symbol Symbol::forLayout(LayoutConstraint layout,
 /// Creates a superclass symbol, representing a superclass constraint.
 Symbol Symbol::forSuperclass(CanType type, ArrayRef<Term> substitutions,
                              RewriteContext &ctx) {
+  ASSERT(type.getClassOrBoundGenericClass() != nullptr);
+
   llvm::FoldingSetNodeID id;
   id.AddInteger(unsigned(Kind::Superclass));
   id.AddPointer(type.getPointer());

lib/AST/TypeSubstitution.cpp

@@ -523,14 +523,20 @@ Type TypeBase::getSuperclassForDecl(const ClassDecl *baseClass,
     t = t->getSuperclass(useArchetypes);
   }
 
-#ifndef NDEBUG
-  auto *currentClass = getConcreteTypeForSuperclassTraversing(this)
-      ->getClassOrBoundGenericClass();
-  assert(baseClass->isSuperclassOf(currentClass) &&
-         "no inheritance relationship between given classes");
-#endif
-
-  return ErrorType::get(this);
+  if (CONDITIONAL_ASSERT_enabled()) {
+    auto *currentClass = getConcreteTypeForSuperclassTraversing(this)
+        ->getClassOrBoundGenericClass();
+    ASSERT(baseClass->isSuperclassOf(currentClass) &&
+           "no inheritance relationship between given classes");
+  }
+
+  // We can end up here if the AST is invalid, because then
+  // getSuperclassDecl() might resolve to a decl, and yet
+  // getSuperclass() is just an ErrorType. Make sure we still
+  // return a nominal type as the result though, and not an
+  // ErrorType, because that's what callers expect.
+  return baseClass->getDeclaredInterfaceType()
+      .subst(SubstitutionMap())->getCanonicalType();
 }
 
 SubstitutionMap TypeBase::getContextSubstitutionMap() {
@@ -546,7 +552,7 @@ SubstitutionMap TypeBase::getContextSubstitutionMap() {
 
   Type baseTy(this);
 
-  assert(!baseTy->hasLValueType() &&
+  assert(!baseTy->is<LValueType>() &&
          !baseTy->is<AnyMetatypeType>() &&
          !baseTy->is<ErrorType>());
 
@@ -628,7 +634,7 @@ TypeBase::getContextSubstitutions(const DeclContext *dc,
   assert(dc->isTypeContext());
   Type baseTy(this);
 
-  assert(!baseTy->hasLValueType() &&
+  assert(!baseTy->is<LValueType>() &&
          !baseTy->is<AnyMetatypeType>() &&
          !baseTy->is<ErrorType>());
 

lib/IRGen/ClassMetadataVisitor.h

@@ -210,7 +210,8 @@ template <class Impl> class ClassMetadataVisitor
     // whether they need them or not.
     asImpl().noteStartOfFieldOffsets(theClass);
     forEachField(IGM, theClass, [&](Field field) {
-      asImpl().addFieldEntries(field);
+      if (isExportableField(field))
+        asImpl().addFieldEntries(field);
     });
     asImpl().noteEndOfFieldOffsets(theClass);
 

lib/IRGen/GenMeta.cpp

@@ -2409,7 +2409,7 @@ namespace {
       B.addInt32(numImmediateMembers);
 
       // uint32_t NumFields;
-      B.addInt32(getNumFields(getType()));
+      B.addInt32(countExportableFields(IGM, getType()));
 
       // uint32_t FieldOffsetVectorOffset;
       B.addInt32(getFieldVectorOffset() / IGM.getPointerSize());

lib/Sema/TypeCheckStorage.cpp

@@ -1146,12 +1146,7 @@ static Expr *buildStorageReference(AccessorDecl *accessor,
       auto *baseClass = override->getDeclContext()->getSelfClassDecl();
       selfTypeForAccess = selfTypeForAccess->getSuperclassForDecl(baseClass);
 
-      // Error recovery path. We get an ErrorType here if getSuperclassForDecl()
-      // fails (because, for instance, a generic parameter of a generic nominal
-      // type cannot be resolved).
-      if (!selfTypeForAccess->is<ErrorType>()) {
-        subs = selfTypeForAccess->getContextSubstitutionMap(baseClass);
-      }
+      subs = selfTypeForAccess->getContextSubstitutionMap(baseClass);
 
       storage = override;
 

stdlib/public/core/DebuggerSupport.swift

@@ -158,7 +158,7 @@ public enum _DebuggerSupport {
       default:
         return value.map(String.init(reflecting:))
       }
-    case .`class`?:
+    case .`class`?, .foreignReference?:
       switch value {
       case let x as CustomDebugStringConvertible:
         return x.debugDescription

stdlib/public/core/Mirror.swift

@@ -313,6 +313,7 @@ extension Mirror {
   public enum DisplayStyle: Sendable {
     case `struct`, `class`, `enum`, tuple, optional, collection
     case dictionary, `set`
+    @available(SwiftStdlib 6.2, *) case foreignReference
   }
 
   internal static func _noSuperclassMirror() -> Mirror? { return nil }
@@ -481,6 +482,7 @@ public struct Mirror {
   public enum DisplayStyle: Sendable {
     case `struct`, `class`, `enum`, tuple, optional, collection
     case dictionary, `set`
+    @available(SwiftStdlib 6.2, *) case foreignReference
   }
   public init<Subject, C: Collection>(
     _ subject: Subject,

stdlib/public/core/OutputStream.swift

@@ -381,6 +381,10 @@ internal func _adHocPrint_unlocked<T, TargetStream: TextOutputStream>(
             target.write(")")
           }
         }
+      case .foreignReference:
+        printTypeName(mirror.subjectType)
+        // FRT has no children
+        target.write("()")
       default:
         target.write(_typeName(mirror.subjectType))
     }
@@ -526,7 +530,7 @@ internal func _dumpPrint_unlocked<T, TargetStream: TextOutputStream>(
 
   if let displayStyle = mirror.displayStyle {
     switch displayStyle {
-    case .`class`, .`struct`:
+    case .`class`, .`struct`, .foreignReference:
       // Classes and structs without custom representations are displayed as
       // their fully qualified type name
       target.write(_typeName(mirror.subjectType, qualified: true))

stdlib/public/core/ReflectionMirror.swift

@@ -172,6 +172,12 @@ extension Mirror {
     case "e": self.displayStyle = .enum
     case "s": self.displayStyle = .struct
     case "t": self.displayStyle = .tuple
+    case "f":  
+      if #available(SwiftStdlib 6.2, *) {
+        self.displayStyle = .foreignReference
+      } else {
+        self.displayStyle = nil
+      }
     case "\0": self.displayStyle = nil
     default: preconditionFailure("Unknown raw display style '\(rawDisplayStyle)'")
     }

test/Generics/unify_superclass_types_invalid.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: not %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+
+class Base<T> {}
+class Derived : Base<Foo> {}
+// expected-error@-1 {{cannot find type 'Foo' in scope}}
+
+// CHECK-LABEL: unify_superclass_types_invalid.(file).f@
+// CHECK: Generic signature: <T where T : Derived>
+func f<T>(_: T) where T: Base<Int>, T: Derived {}

test/Interop/Cxx/class/Inputs/mirror.h

@@ -0,0 +1,49 @@
+#ifndef TEST_INTEROP_CXX_METADATA_INPUTS_MIRROR_H
+#define TEST_INTEROP_CXX_METADATA_INPUTS_MIRROR_H
+
+struct EmptyStruct {};
+
+struct BaseStruct {
+private:
+  int priv;
+
+public:
+  int publ;
+
+protected:
+  int prot;
+
+public:
+  BaseStruct(int i1, int i2, int i3) : priv(i1), publ(i2), prot(i3) {}
+};
+
+class EmptyClass {};
+
+struct OuterStruct {
+private:
+  BaseStruct privStruct;
+
+public:
+  BaseStruct publStruct;
+
+  OuterStruct() : privStruct(1, 2, 3), publStruct(4, 5, 6) {}
+};
+
+struct FRTStruct {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retain")))
+__attribute__((swift_attr("release:release")));
+
+void retain(FRTStruct *v) {};
+void release(FRTStruct *v) {};
+
+class FRTImmortalClass {} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+#endif

test/Interop/Cxx/class/Inputs/module.modulemap

@@ -158,3 +158,9 @@ module SimpleStructs {
   requires cplusplus
   export *
 }
+
+module Mirror {
+  header "mirror.h"
+  requires cplusplus
+  export *
+}

test/Interop/Cxx/class/Inputs/simple-structs.h

@@ -52,4 +52,38 @@ struct Outer {
   Outer() : privStruct(1, 2, 3, 4, 5, 6), publStruct(7, 8, 9, 10, 11, 12) {}
 };
 
+struct ImmortalFRT {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+struct FRTCustomStringConvertible {
+public:
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+struct FRType {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retain")))
+__attribute__((swift_attr("release:release")));
+
+void retain(FRType *v) {};
+void release(FRType *v) {};
+
 #endif

test/Interop/Cxx/class/mirror.swift

@@ -0,0 +1,97 @@
+// RUN: %target-run-simple-swift(-cxx-interoperability-mode=default -I %S/Inputs)
+
+// REQUIRES: executable_test
+// Metadata for foreign reference types is not supported on Windows.
+// UNSUPPORTED: OS=windows-msvc
+
+import StdlibUnittest
+import Mirror
+
+var MirrorTestSuite = TestSuite("Mirrors")
+
+MirrorTestSuite.test("EmptyCxxStruct") {
+  let s = EmptyStruct()
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == EmptyStruct.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.EmptyStruct\n", output)
+}
+
+MirrorTestSuite.test("EmptyCxxClass") {
+  let s = EmptyClass()
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == EmptyClass.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.EmptyClass\n", output)
+}
+
+MirrorTestSuite.test("CxxStructWithFields") {
+  let s = BaseStruct(1, 2, 3)
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == BaseStruct.self)
+  expectEqual(1, m.children.count)
+
+  expectEqual("publ", m.children.first!.label)
+  expectEqual(2, m.children.first!.value as? Int32)
+  
+  var output = ""
+  dump(s, to: &output)
+  let expected = 
+    "▿ __C.BaseStruct\n" +
+    "  - publ: 2\n"
+  expectEqual(expected, output)
+}
+
+MirrorTestSuite.test("CxxStructWithStructsAsFields") {
+  let s = OuterStruct()
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == OuterStruct.self)
+  expectEqual(1, m.children.count)
+  expectEqual("publStruct", m.children.first!.label)
+  
+  var output = ""
+  dump(s, to: &output)
+  let expected = 
+    "▿ __C.OuterStruct\n" +
+    "  ▿ publStruct: __C.BaseStruct\n" +
+    "    - publ: 5\n"    
+  expectEqual(expected, output)
+}
+
+if #available(SwiftStdlib 6.2, *) {
+  MirrorTestSuite.test("CxxFRTStruct") {
+    let s = FRTStruct()
+    let m = Mirror(reflecting: s)
+    expectEqual(.foreignReference, m.displayStyle)
+    expectTrue(m.subjectType == FRTStruct.self)
+    expectEqual(0, m.children.count)
+
+    var output = ""
+    dump(s, to: &output)
+    expectEqual("- __C.FRTStruct\n", output)
+  }
+
+  MirrorTestSuite.test("CxxFRTImmortalClass") {
+    let s = FRTImmortalClass()
+    let m = Mirror(reflecting: s)
+    expectEqual(.foreignReference, m.displayStyle)
+    expectTrue(m.subjectType == FRTImmortalClass.self)
+    expectEqual(0, m.children.count)
+
+    var output = ""
+    dump(s, to: &output)
+    expectEqual("- __C.FRTImmortalClass\n", output)
+  }
+}
+
+runAllTests()