Skip to content

[ParseableInterface] Skip extensions with non-public constraints #20146

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Nov 7, 2018
Merged

[ParseableInterface] Skip extensions with non-public constraints #20146

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
31 changes: 29 additions & 2 deletions lib/AST/ASTPrinter.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -71,6 +71,20 @@ static bool isPublicOrUsableFromInline(const ValueDecl *VD) {
return scope.isPublic();
}

static bool isPublicOrUsableFromInline(Type ty) {
// Note the double negative here: we're looking for any referenced decls that
// are *not* public-or-usableFromInline.
return !ty.findIf([](Type typePart) -> bool {
// FIXME: If we have an internal typealias for a non-internal type, we ought
// to be able to print it by desugaring.
if (auto *aliasTy = dyn_cast<NameAliasType>(typePart.getPointer()))
return !isPublicOrUsableFromInline(aliasTy->getDecl());
if (auto *nominal = typePart->getAnyNominal())
return !isPublicOrUsableFromInline(nominal);
return false;
});
}

static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
auto *DC = ASD->getDeclContext()->getAsDecl();
if (!DC) return false;
Expand Down Expand Up @@ -118,8 +132,21 @@ PrintOptions PrintOptions::printParseableInterfaceFile() {
if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
if (!shouldPrint(ED->getExtendedNominal(), options))
return false;
// FIXME: We also need to check the generic signature for constraints
// that we can't reference.
for (const Requirement &req : ED->getGenericRequirements()) {
if (!isPublicOrUsableFromInline(req.getFirstType()))
return false;

switch (req.getKind()) {
case RequirementKind::Conformance:
case RequirementKind::Superclass:
case RequirementKind::SameType:
if (!isPublicOrUsableFromInline(req.getSecondType()))
return false;
break;
case RequirementKind::Layout:
break;
}
}
}

// Skip typealiases that just redeclare generic parameters.
Expand Down
136 changes: 136 additions & 0 deletions test/ParseableInterface/access-filter.swift
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -149,3 +149,139 @@ enum InternalEnum_BAD {
// CHECK-NEXT: case y(Int)
case y(Int)
} // CHECK-NEXT: {{^[}]$}}

// CHECK: public class PublicClass {{[{]$}}
public class PublicClass {
} // CHECK: {{^[}]$}}

class InternalClass_BAD {
}

// CHECK: @usableFromInline
// CHECK-NEXT: internal class UFIClass {{[{]$}}
@usableFromInline class UFIClass {
} // CHECK: {{^[}]$}}

// CHECK: public struct GenericStruct<T>
public struct GenericStruct<T> {}

// CHECK: extension GenericStruct where T == main.PublicStruct {{[{]$}}
extension GenericStruct where T == PublicStruct {
// CHECK-NEXT: public func constrainedToPublicStruct(){{$}}
public func constrainedToPublicStruct() {}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension GenericStruct where T == main.UFIStruct {{[{]$}}
extension GenericStruct where T == UFIStruct {
// CHECK-NEXT: @usableFromInline{{$}}
// CHECK-NEXT: internal func constrainedToUFIStruct(){{$}}
@usableFromInline internal func constrainedToUFIStruct() {}
} // CHECK-NEXT: {{^[}]$}}
extension GenericStruct where T == InternalStruct_BAD {
@usableFromInline internal func constrainedToInternalStruct_BAD() {}
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we even be allowing people to declare this? It's not actually callable.

}

// CHECK: extension GenericStruct where T == main.PublicStruct {{[{]$}}
extension GenericStruct where PublicStruct == T {
// CHECK-NEXT: public func constrainedToPublicStruct2(){{$}}
public func constrainedToPublicStruct2() {}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension GenericStruct where T == main.UFIStruct {{[{]$}}
extension GenericStruct where UFIStruct == T {
// CHECK-NEXT: @usableFromInline{{$}}
// CHECK-NEXT: internal func constrainedToUFIStruct2(){{$}}
@usableFromInline internal func constrainedToUFIStruct2() {}
} // CHECK-NEXT: {{^[}]$}}
extension GenericStruct where InternalStruct_BAD == T {
@usableFromInline internal func constrainedToInternalStruct2_BAD() {}
}

// CHECK: extension GenericStruct where T : PublicProto {{[{]$}}
extension GenericStruct where T: PublicProto {
// CHECK-NEXT: public func constrainedToPublicProto(){{$}}
public func constrainedToPublicProto() {}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension GenericStruct where T : UFIProto {{[{]$}}
extension GenericStruct where T: UFIProto {
// CHECK-NEXT: @usableFromInline{{$}}
// CHECK-NEXT: internal func constrainedToUFIProto(){{$}}
@usableFromInline internal func constrainedToUFIProto() {}
} // CHECK-NEXT: {{^[}]$}}
extension GenericStruct where T: InternalProto_BAD {
@usableFromInline internal func constrainedToInternalProto_BAD() {}
}

// CHECK: extension GenericStruct where T : main.PublicClass {{[{]$}}
extension GenericStruct where T: PublicClass {
// CHECK-NEXT: public func constrainedToPublicClass(){{$}}
public func constrainedToPublicClass() {}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension GenericStruct where T : main.UFIClass {{[{]$}}
extension GenericStruct where T: UFIClass {
// CHECK-NEXT: @usableFromInline{{$}}
// CHECK-NEXT: internal func constrainedToUFIClass(){{$}}
@usableFromInline internal func constrainedToUFIClass() {}
} // CHECK-NEXT: {{^[}]$}}
extension GenericStruct where T: InternalClass_BAD {
@usableFromInline internal func constrainedToInternalClass_BAD() {}
}

// CHECK: extension GenericStruct where T : AnyObject {{[{]$}}
extension GenericStruct where T: AnyObject {
// CHECK-NEXT: public func constrainedToAnyObject(){{$}}
public func constrainedToAnyObject() {}
} // CHECK-NEXT: {{^[}]$}}

public struct PublicAliasBase {}
internal struct ReallyInternalAliasBase_BAD {}

// CHECK: public typealias PublicAlias = PublicAliasBase
public typealias PublicAlias = PublicAliasBase
internal typealias InternalAlias_BAD = PublicAliasBase
// CHECK: @usableFromInline
// CHECK-NEXT: internal typealias UFIAlias = PublicAliasBase
@usableFromInline internal typealias UFIAlias = PublicAliasBase

internal typealias ReallyInternalAlias_BAD = ReallyInternalAliasBase_BAD

// CHECK: extension GenericStruct where T == PublicAlias {{[{]$}}
extension GenericStruct where T == PublicAlias {
// CHECK-NEXT: public func constrainedToPublicAlias(){{$}}
public func constrainedToPublicAlias() {}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension GenericStruct where T == UFIAlias {{[{]$}}
extension GenericStruct where T == UFIAlias {
// CHECK-NEXT: @usableFromInline{{$}}
// CHECK-NEXT: internal func constrainedToUFIAlias(){{$}}
@usableFromInline internal func constrainedToUFIAlias() {}
} // CHECK-NEXT: {{^[}]$}}
extension GenericStruct where T == InternalAlias_BAD {
// FIXME: We could print this one by desugaring; it is indeed public.
@usableFromInline internal func constrainedToInternalAlias() {}
}
extension GenericStruct where T == ReallyInternalAlias_BAD {
@usableFromInline internal func constrainedToPrivateAlias() {}
}

extension GenericStruct {
// For the next extension's test.
public func requirement() {}
}
extension GenericStruct: PublicProto where T: InternalProto_BAD {
@usableFromInline internal func conformance_BAD() {}
}


public struct MultiGenericStruct<First, Second> {}

// CHECK: extension MultiGenericStruct where First == main.PublicStruct, Second == main.PublicStruct {{[{]$}}
extension MultiGenericStruct where First == PublicStruct, Second == PublicStruct {
// CHECK-NEXT: public func publicPublic(){{$}}
public func publicPublic() {}
} // CHECK-NEXT: {{^[}]$}}

extension MultiGenericStruct where First == PublicStruct, Second == InternalStruct_BAD {
@usableFromInline internal func publicInternal_BAD() {}
}
extension MultiGenericStruct where First == InternalStruct_BAD, Second == PublicStruct {
@usableFromInline internal func internalPublic_BAD() {}
}