Attachment: Download

Issue Description:

I've found two ways in which the emitted .swiftinterface file can contain Swift errors, breaking module compatibility. This can break binary Swift frameworks across Xcode updates. This was really confusing to us for the past 6 months but it seems Swift only uses this file when compiling with a different compiler.

The first issue is if the module contains a type with the same name, the swiftinterface file breaks completely. This file qualifies every referenced type name from the current module with the module name as well, but because the name conflicts with a type from the file, the compiler interprets these paths as relative to the type, not the module, and fails to look up all of the referenced types. I suspect this can happen when referring to types from an imported module that has the same setup, but I haven't tried that specific scenario. (Tracked by SR-898.)

The other example is more insidious. It turns out that you can write Swift code where an associatedtype is inferred and it compiles just fine, but writing out the explicit typealias instead of inferring it causes behavior to change. In particular, the following code triggers this behavior:

public struct ReplaySubject: SubjectType {
    public typealias SubjectObserverType = ReplaySubject
    // The following gets inferred by the compiler:
    //     public typealias Observer = ReplaySubject.SubjectObserverType
    // It works as long as it's inferred, but when made explicit in the
    // .swiftinterface it breaks.
    public func asObserver() -> SubjectObserverType {
        fatalError()
    }
}

public protocol SubjectType {
    associatedtype Observer
    @available(*, deprecated)
    typealias SubjectObserverType = Self.Observer
    func asObserver() -> Self.Observer
}

With the typealias written out explicitly, this code will complain "type alias 'Observer' references itself". It seems that it ends up evaluating the reference to ReplaySubject.SubjectObserverType using the typealias from SubjectType instead of the typealias from ReplaySubject. But this only happens when the reference is qualified, writing this as typealias Observer = SubjectObserverType compiles just fine.

The typealias thing here definitely seems like a bug in general, but this particular ticket is concerned with the fact that the generated .swiftinterface can trigger it when the original source didn't.

I've attached a zipped SPM project that can be used to reproduce this.

The second swift build will produce the above errors.

The generated swiftinterface files for reference:

// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 5.3.2 (swiftlang-1200.0.45 clang-1200.0.32.28)
// swift-module-flags: -target x86_64-apple-macosx10.10 -enable-objc-interop -enable-library-evolution -swift-version 5 -Onone -module-name SameName
import Swift
public struct SameName {
}
public struct SomethingElse {
  public typealias Foo = SameName.Bar
}
public struct Bar {
}

// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 5.3.2 (swiftlang-1200.0.45 clang-1200.0.32.28)
// swift-module-flags: -target x86_64-apple-macosx10.10 -enable-objc-interop -enable-library-evolution -swift-version 5 -Onone -module-name TypeAlias
import Swift
public struct ReplaySubject : TypeAlias.SubjectType {
  public typealias SubjectObserverType = TypeAlias.ReplaySubject
  public typealias Observer = TypeAlias.ReplaySubject.SubjectObserverType
  public func asObserver() -> TypeAlias.ReplaySubject.SubjectObserverType
}
public protocol SubjectType {
  associatedtype Observer
  @available(*, deprecated)
  typealias SubjectObserverType = Self.Observer
  func asObserver() -> Self.Observer
}