mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
77a76c9900
'lookupTypeMembers()' accepts 'BaseTy' to check found value decls are applicable to the type. When looking into super classes, it used to use the interface type of the super class which was not good. Instead, use the original "base type" consistently. rdar://problem/69308207 https://bugs.swift.org/browse/SR-13574
1366 lines
48 KiB
C++
1366 lines
48 KiB
C++
//===--- LookupVisibleDecls - Swift Name Lookup Routines ------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the lookupVisibleDecls interface for visiting named
|
|
// declarations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "TypeChecker.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/GenericSignature.h"
|
|
#include "swift/AST/GenericSignatureBuilder.h"
|
|
#include "swift/AST/ImportCache.h"
|
|
#include "swift/AST/Initializer.h"
|
|
#include "swift/AST/LazyResolver.h"
|
|
#include "swift/AST/ModuleNameLookup.h"
|
|
#include "swift/AST/NameLookup.h"
|
|
#include "swift/AST/ProtocolConformance.h"
|
|
#include "swift/AST/PropertyWrappers.h"
|
|
#include "swift/AST/SourceFile.h"
|
|
#include "swift/Basic/SourceManager.h"
|
|
#include "swift/Basic/STLExtras.h"
|
|
#include "swift/Sema/IDETypeCheckingRequests.h"
|
|
#include "swift/Sema/IDETypeChecking.h"
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include <set>
|
|
|
|
using namespace swift;
|
|
|
|
namespace {
|
|
struct LookupState {
|
|
private:
|
|
/// If \c false, an unqualified lookup of all visible decls in a
|
|
/// DeclContext.
|
|
///
|
|
/// If \c true, lookup of all visible members of a given object (possibly of
|
|
/// metatype type).
|
|
unsigned IsQualified : 1;
|
|
|
|
/// Is this a qualified lookup on a metatype?
|
|
unsigned IsOnMetatype : 1;
|
|
|
|
/// Did we recurse into a superclass?
|
|
unsigned IsOnSuperclass : 1;
|
|
|
|
unsigned InheritsSuperclassInitializers : 1;
|
|
|
|
/// Should instance members be included even if lookup is performed on a type?
|
|
unsigned IncludeInstanceMembers : 1;
|
|
|
|
/// Should derived protocol requirements be included?
|
|
/// This option is only for override completion lookup.
|
|
unsigned IncludeDerivedRequirements : 1;
|
|
|
|
/// Should protocol extension members be included?
|
|
unsigned IncludeProtocolExtensionMembers : 1;
|
|
|
|
LookupState()
|
|
: IsQualified(0), IsOnMetatype(0), IsOnSuperclass(0),
|
|
InheritsSuperclassInitializers(0), IncludeInstanceMembers(0),
|
|
IncludeDerivedRequirements(0), IncludeProtocolExtensionMembers(0) {}
|
|
|
|
public:
|
|
LookupState(const LookupState &) = default;
|
|
|
|
static LookupState makeQualified() {
|
|
LookupState Result;
|
|
Result.IsQualified = 1;
|
|
return Result;
|
|
}
|
|
|
|
static LookupState makeUnqualified() {
|
|
LookupState Result;
|
|
Result.IsQualified = 0;
|
|
return Result;
|
|
}
|
|
|
|
bool isQualified() const { return IsQualified; }
|
|
bool isOnMetatype() const { return IsOnMetatype; }
|
|
bool isOnSuperclass() const { return IsOnSuperclass; }
|
|
bool isInheritsSuperclassInitializers() const {
|
|
return InheritsSuperclassInitializers;
|
|
}
|
|
bool isIncludingInstanceMembers() const { return IncludeInstanceMembers; }
|
|
bool isIncludingDerivedRequirements() const {
|
|
return IncludeDerivedRequirements;
|
|
}
|
|
bool isIncludingProtocolExtensionMembers() const {
|
|
return IncludeProtocolExtensionMembers;
|
|
}
|
|
|
|
LookupState withOnMetatype() const {
|
|
auto Result = *this;
|
|
Result.IsOnMetatype = 1;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withOnSuperclass() const {
|
|
auto Result = *this;
|
|
Result.IsOnSuperclass = 1;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withInheritsSuperclassInitializers() const {
|
|
auto Result = *this;
|
|
Result.InheritsSuperclassInitializers = 1;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withoutInheritsSuperclassInitializers() const {
|
|
auto Result = *this;
|
|
Result.InheritsSuperclassInitializers = 0;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withIncludedInstanceMembers() const {
|
|
auto Result = *this;
|
|
Result.IncludeInstanceMembers = 1;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withIncludedDerivedRequirements() const {
|
|
auto Result = *this;
|
|
Result.IncludeDerivedRequirements = 1;
|
|
return Result;
|
|
}
|
|
|
|
LookupState withIncludeProtocolExtensionMembers() const {
|
|
auto Result = *this;
|
|
Result.IncludeProtocolExtensionMembers = 1;
|
|
return Result;
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
static bool areTypeDeclsVisibleInLookupMode(LookupState LS) {
|
|
// Nested type declarations can be accessed only with unqualified lookup or
|
|
// on metatypes.
|
|
return !LS.isQualified() || LS.isOnMetatype();
|
|
}
|
|
|
|
static bool isDeclVisibleInLookupMode(ValueDecl *Member, LookupState LS,
|
|
const DeclContext *FromContext) {
|
|
// Accessors are never visible directly in the source language.
|
|
if (isa<AccessorDecl>(Member))
|
|
return false;
|
|
|
|
// Check access when relevant.
|
|
if (!Member->getDeclContext()->isLocalContext() &&
|
|
!isa<GenericTypeParamDecl>(Member) && !isa<ParamDecl>(Member)) {
|
|
if (!Member->isAccessibleFrom(FromContext))
|
|
return false;
|
|
}
|
|
|
|
if (auto *FD = dyn_cast<FuncDecl>(Member)) {
|
|
// Cannot call static functions on non-metatypes.
|
|
if (!LS.isOnMetatype() && FD->isStatic())
|
|
return false;
|
|
|
|
// Otherwise, either call a function or curry it.
|
|
return true;
|
|
}
|
|
if (auto *SD = dyn_cast<SubscriptDecl>(Member)) {
|
|
// Cannot use static subscripts on non-metatypes.
|
|
if (!LS.isOnMetatype() && SD->isStatic())
|
|
return false;
|
|
|
|
// Cannot use instance subscript on metatypes.
|
|
if (LS.isOnMetatype() && !SD->isStatic() && !LS.isIncludingInstanceMembers())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
if (auto *VD = dyn_cast<VarDecl>(Member)) {
|
|
// Cannot use static properties on non-metatypes.
|
|
if (!LS.isOnMetatype() && VD->isStatic())
|
|
return false;
|
|
|
|
// Cannot use instance properties on metatypes.
|
|
if (LS.isOnMetatype() && !VD->isStatic() && !LS.isIncludingInstanceMembers())
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
if (isa<EnumElementDecl>(Member)) {
|
|
// Cannot reference enum elements on non-metatypes.
|
|
if (!LS.isOnMetatype())
|
|
return false;
|
|
}
|
|
if (auto CD = dyn_cast<ConstructorDecl>(Member)) {
|
|
if (!LS.isQualified())
|
|
return false;
|
|
// Constructors with stub implementations cannot be called in Swift.
|
|
if (CD->hasStubImplementation())
|
|
return false;
|
|
if (LS.isOnSuperclass()) {
|
|
// Cannot call initializers from a superclass, except for inherited
|
|
// convenience initializers.
|
|
return LS.isInheritsSuperclassInitializers() && CD->isInheritable();
|
|
}
|
|
}
|
|
if (isa<TypeDecl>(Member))
|
|
return areTypeDeclsVisibleInLookupMode(LS);
|
|
|
|
return true;
|
|
}
|
|
|
|
/// Collect visble members from \p Parent into \p FoundDecls .
|
|
static void collectVisibleMemberDecls(const DeclContext *CurrDC, LookupState LS,
|
|
Type BaseType,
|
|
IterableDeclContext *Parent,
|
|
SmallVectorImpl<ValueDecl *> &FoundDecls) {
|
|
for (auto Member : Parent->getMembers()) {
|
|
auto *VD = dyn_cast<ValueDecl>(Member);
|
|
if (!VD)
|
|
continue;
|
|
if (!isDeclVisibleInLookupMode(VD, LS, CurrDC))
|
|
continue;
|
|
if (!evaluateOrDefault(CurrDC->getASTContext().evaluator,
|
|
IsDeclApplicableRequest(DeclApplicabilityOwner(CurrDC, BaseType, VD)),
|
|
false))
|
|
continue;
|
|
FoundDecls.push_back(VD);
|
|
}
|
|
}
|
|
|
|
static void
|
|
synthesizePropertyWrapperVariables(IterableDeclContext *IDC);
|
|
|
|
/// Lookup members in extensions of \p LookupType, using \p BaseType as the
|
|
/// underlying type when checking any constraints on the extensions.
|
|
static void doGlobalExtensionLookup(Type BaseType,
|
|
Type LookupType,
|
|
SmallVectorImpl<ValueDecl *> &FoundDecls,
|
|
const DeclContext *CurrDC,
|
|
LookupState LS,
|
|
DeclVisibilityKind Reason) {
|
|
auto nominal = LookupType->getAnyNominal();
|
|
|
|
// Look in each extension of this type.
|
|
for (auto extension : nominal->getExtensions()) {
|
|
if (!evaluateOrDefault(CurrDC->getASTContext().evaluator,
|
|
IsDeclApplicableRequest(DeclApplicabilityOwner(CurrDC, BaseType,
|
|
extension)), false))
|
|
continue;
|
|
|
|
synthesizePropertyWrapperVariables(extension);
|
|
|
|
collectVisibleMemberDecls(CurrDC, LS, BaseType, extension, FoundDecls);
|
|
}
|
|
|
|
// Handle shadowing.
|
|
removeShadowedDecls(FoundDecls, CurrDC);
|
|
}
|
|
|
|
/// Enumerate immediate members of the type \c LookupType and its
|
|
/// extensions, as seen from the context \c CurrDC.
|
|
///
|
|
/// Don't do lookup into superclasses or implemented protocols. Uses
|
|
/// \p BaseType as the underlying type when checking any constraints on the
|
|
/// extensions.
|
|
static void lookupTypeMembers(Type BaseType, Type LookupType,
|
|
VisibleDeclConsumer &Consumer,
|
|
const DeclContext *CurrDC, LookupState LS,
|
|
DeclVisibilityKind Reason) {
|
|
NominalTypeDecl *D = LookupType->getAnyNominal();
|
|
assert(D && "should have a nominal type");
|
|
|
|
SmallVector<ValueDecl*, 2> FoundDecls;
|
|
collectVisibleMemberDecls(CurrDC, LS, BaseType, D, FoundDecls);
|
|
|
|
doGlobalExtensionLookup(BaseType, LookupType, FoundDecls, CurrDC, LS, Reason);
|
|
|
|
// Report the declarations we found to the consumer.
|
|
for (auto *VD : FoundDecls)
|
|
Consumer.foundDecl(VD, Reason);
|
|
}
|
|
|
|
/// Enumerate AnyObject declarations as seen from context \c CurrDC.
|
|
static void doDynamicLookup(VisibleDeclConsumer &Consumer,
|
|
const DeclContext *CurrDC,
|
|
LookupState LS) {
|
|
class DynamicLookupConsumer : public VisibleDeclConsumer {
|
|
VisibleDeclConsumer &ChainedConsumer;
|
|
LookupState LS;
|
|
const DeclContext *CurrDC;
|
|
llvm::DenseSet<std::pair<DeclBaseName, CanType>> FunctionsReported;
|
|
llvm::DenseSet<CanType> SubscriptsReported;
|
|
llvm::DenseSet<std::pair<Identifier, CanType>> PropertiesReported;
|
|
|
|
public:
|
|
explicit DynamicLookupConsumer(VisibleDeclConsumer &ChainedConsumer,
|
|
LookupState LS, const DeclContext *CurrDC)
|
|
: ChainedConsumer(ChainedConsumer), LS(LS), CurrDC(CurrDC) {}
|
|
|
|
void foundDecl(ValueDecl *D, DeclVisibilityKind Reason,
|
|
DynamicLookupInfo) override {
|
|
// If the declaration has an override, name lookup will also have found
|
|
// the overridden method. Skip this declaration, because we prefer the
|
|
// overridden method.
|
|
if (D->getOverriddenDecl())
|
|
return;
|
|
|
|
// If the declaration is not @objc, it cannot be called dynamically.
|
|
if (!D->isObjC())
|
|
return;
|
|
|
|
if (D->isRecursiveValidation())
|
|
return;
|
|
|
|
switch (D->getKind()) {
|
|
#define DECL(ID, SUPER) \
|
|
case DeclKind::ID:
|
|
#define VALUE_DECL(ID, SUPER)
|
|
#include "swift/AST/DeclNodes.def"
|
|
llvm_unreachable("not a ValueDecl!");
|
|
|
|
// Types cannot be found by dynamic lookup.
|
|
case DeclKind::GenericTypeParam:
|
|
case DeclKind::AssociatedType:
|
|
case DeclKind::TypeAlias:
|
|
case DeclKind::Enum:
|
|
case DeclKind::Class:
|
|
case DeclKind::Struct:
|
|
case DeclKind::Protocol:
|
|
case DeclKind::OpaqueType:
|
|
return;
|
|
|
|
// Initializers cannot be found by dynamic lookup.
|
|
case DeclKind::Constructor:
|
|
case DeclKind::Destructor:
|
|
return;
|
|
|
|
// These cases are probably impossible here but can also just
|
|
// be safely ignored.
|
|
case DeclKind::Param:
|
|
case DeclKind::Module:
|
|
case DeclKind::EnumElement:
|
|
return;
|
|
|
|
// For other kinds of values, check if we already reported a decl
|
|
// with the same signature.
|
|
|
|
case DeclKind::Accessor:
|
|
case DeclKind::Func: {
|
|
auto FD = cast<FuncDecl>(D);
|
|
assert(FD->hasImplicitSelfDecl() && "should not find free functions");
|
|
(void)FD;
|
|
|
|
if (FD->isInvalid())
|
|
break;
|
|
|
|
// Get the type without the first uncurry level with 'self'.
|
|
CanType T = FD->getMethodInterfaceType()->getCanonicalType();
|
|
|
|
auto Signature = std::make_pair(D->getBaseName(), T);
|
|
if (!FunctionsReported.insert(Signature).second)
|
|
return;
|
|
break;
|
|
}
|
|
|
|
case DeclKind::Subscript: {
|
|
auto Signature = D->getInterfaceType()->getCanonicalType();
|
|
if (!SubscriptsReported.insert(Signature).second)
|
|
return;
|
|
break;
|
|
}
|
|
|
|
case DeclKind::Var: {
|
|
auto *VD = cast<VarDecl>(D);
|
|
auto Signature =
|
|
std::make_pair(VD->getName(),
|
|
VD->getInterfaceType()->getCanonicalType());
|
|
if (!PropertiesReported.insert(Signature).second)
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isDeclVisibleInLookupMode(D, LS, CurrDC))
|
|
ChainedConsumer.foundDecl(D, DeclVisibilityKind::DynamicLookup,
|
|
DynamicLookupInfo::AnyObject);
|
|
}
|
|
};
|
|
|
|
DynamicLookupConsumer ConsumerWrapper(Consumer, LS, CurrDC);
|
|
|
|
for (auto Import : namelookup::getAllImports(CurrDC)) {
|
|
Import.importedModule->lookupClassMembers(Import.accessPath,
|
|
ConsumerWrapper);
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
typedef llvm::SmallPtrSet<TypeDecl *, 8> VisitedSet;
|
|
} // end anonymous namespace
|
|
|
|
static DeclVisibilityKind getReasonForSuper(DeclVisibilityKind Reason) {
|
|
switch (Reason) {
|
|
case DeclVisibilityKind::MemberOfCurrentNominal:
|
|
case DeclVisibilityKind::MemberOfProtocolConformedToByCurrentNominal:
|
|
case DeclVisibilityKind::MemberOfSuper:
|
|
return DeclVisibilityKind::MemberOfSuper;
|
|
|
|
case DeclVisibilityKind::MemberOfOutsideNominal:
|
|
return DeclVisibilityKind::MemberOfOutsideNominal;
|
|
|
|
default:
|
|
llvm_unreachable("should not see this kind");
|
|
}
|
|
}
|
|
|
|
static void lookupDeclsFromProtocolsBeingConformedTo(
|
|
Type BaseTy, VisibleDeclConsumer &Consumer, LookupState LS,
|
|
const DeclContext *FromContext, DeclVisibilityKind Reason,
|
|
VisitedSet &Visited) {
|
|
NominalTypeDecl *CurrNominal = BaseTy->getAnyNominal();
|
|
if (!CurrNominal)
|
|
return;
|
|
ModuleDecl *Module = FromContext->getParentModule();
|
|
|
|
for (auto Conformance : CurrNominal->getAllConformances()) {
|
|
auto Proto = Conformance->getProtocol();
|
|
if (!Proto->isAccessibleFrom(FromContext))
|
|
continue;
|
|
|
|
// Skip unsatisfied conditional conformances.
|
|
// We can't check them if this type has an UnboundGenericType or if they
|
|
// couldn't be computed, so assume they conform in such cases.
|
|
if (!BaseTy->hasUnboundGenericType()) {
|
|
if (auto res = Conformance->getConditionalRequirementsIfAvailable()) {
|
|
if (!res->empty() && !Module->conformsToProtocol(BaseTy, Proto))
|
|
continue;
|
|
}
|
|
}
|
|
|
|
DeclVisibilityKind ReasonForThisProtocol;
|
|
if (Conformance->getKind() == ProtocolConformanceKind::Inherited)
|
|
ReasonForThisProtocol = getReasonForSuper(Reason);
|
|
else if (Reason == DeclVisibilityKind::MemberOfCurrentNominal)
|
|
ReasonForThisProtocol =
|
|
DeclVisibilityKind::MemberOfProtocolConformedToByCurrentNominal;
|
|
else
|
|
ReasonForThisProtocol = getReasonForSuper(Reason);
|
|
|
|
if (auto NormalConformance = dyn_cast<NormalProtocolConformance>(
|
|
Conformance->getRootConformance())) {
|
|
for (auto Member : Proto->getMembers()) {
|
|
// Skip associated types and value requirements that aren't visible
|
|
// or have a corresponding witness.
|
|
if (auto *ATD = dyn_cast<AssociatedTypeDecl>(Member)) {
|
|
if (areTypeDeclsVisibleInLookupMode(LS) &&
|
|
!Conformance->hasTypeWitness(ATD)) {
|
|
Consumer.foundDecl(ATD, ReasonForThisProtocol);
|
|
}
|
|
} else if (auto *VD = dyn_cast<ValueDecl>(Member)) {
|
|
if (!isDeclVisibleInLookupMode(VD, LS, FromContext))
|
|
continue;
|
|
|
|
if (!VD->isProtocolRequirement())
|
|
continue;
|
|
|
|
// Whether the given witness corresponds to a derived requirement.
|
|
const auto isDerivedRequirement = [Proto](const ValueDecl *Witness) {
|
|
return Witness->isImplicit() &&
|
|
Proto->getKnownDerivableProtocolKind();
|
|
};
|
|
DeclVisibilityKind ReasonForThisDecl = ReasonForThisProtocol;
|
|
if (const auto Witness = NormalConformance->getWitness(VD)) {
|
|
auto *WD = Witness.getDecl();
|
|
if (WD->getName() == VD->getName()) {
|
|
if (LS.isIncludingDerivedRequirements() &&
|
|
Reason == DeclVisibilityKind::MemberOfCurrentNominal &&
|
|
isDerivedRequirement(WD)) {
|
|
ReasonForThisDecl =
|
|
DeclVisibilityKind::MemberOfProtocolDerivedByCurrentNominal;
|
|
} else if (!LS.isIncludingProtocolExtensionMembers() &&
|
|
WD->getDeclContext()->getExtendedProtocolDecl()) {
|
|
// Don't skip this requiement.
|
|
// Witnesses in protocol extensions aren't reported.
|
|
} else {
|
|
// lookupVisibleMemberDecls() generally prefers witness members
|
|
// over requirements.
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
Consumer.foundDecl(VD, ReasonForThisDecl);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Add members from any extensions.
|
|
if (LS.isIncludingProtocolExtensionMembers()) {
|
|
SmallVector<ValueDecl *, 2> FoundDecls;
|
|
doGlobalExtensionLookup(BaseTy, Proto->getDeclaredInterfaceType(),
|
|
FoundDecls, FromContext, LS,
|
|
ReasonForThisProtocol);
|
|
for (auto *VD : FoundDecls)
|
|
Consumer.foundDecl(VD, ReasonForThisProtocol);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
lookupVisibleMemberDeclsImpl(Type BaseTy, VisibleDeclConsumer &Consumer,
|
|
const DeclContext *CurrDC, LookupState LS,
|
|
DeclVisibilityKind Reason,
|
|
GenericSignatureBuilder *GSB,
|
|
VisitedSet &Visited);
|
|
|
|
static void
|
|
lookupVisibleProtocolMemberDecls(Type BaseTy, ProtocolDecl *PD,
|
|
VisibleDeclConsumer &Consumer,
|
|
const DeclContext *CurrDC, LookupState LS,
|
|
DeclVisibilityKind Reason,
|
|
GenericSignatureBuilder *GSB,
|
|
VisitedSet &Visited) {
|
|
if (!Visited.insert(PD).second)
|
|
return;
|
|
|
|
for (auto Proto : PD->getInheritedProtocols())
|
|
lookupVisibleProtocolMemberDecls(BaseTy, Proto,
|
|
Consumer, CurrDC, LS,
|
|
getReasonForSuper(Reason),
|
|
GSB, Visited);
|
|
lookupTypeMembers(BaseTy, PD->getDeclaredInterfaceType(),
|
|
Consumer, CurrDC, LS, Reason);
|
|
}
|
|
|
|
// Generate '$' and '_' prefixed variables for members that have attached property
|
|
// wrappers.
|
|
static void
|
|
synthesizePropertyWrapperVariables(IterableDeclContext *IDC) {
|
|
auto SF = IDC->getAsGenericContext()->getParentSourceFile();
|
|
if (!SF || SF->Kind == SourceFileKind::Interface)
|
|
return;
|
|
|
|
for (auto Member : IDC->getMembers())
|
|
if (auto var = dyn_cast<VarDecl>(Member))
|
|
if (var->hasAttachedPropertyWrapper())
|
|
(void)var->getPropertyWrapperBackingPropertyInfo();
|
|
}
|
|
|
|
/// Trigger synthesizing implicit member declarations to make them "visible".
|
|
static void synthesizeMemberDeclsForLookup(NominalTypeDecl *NTD,
|
|
const DeclContext *DC) {
|
|
// Synthesize the memberwise initializer for structs or default initializer
|
|
// for classes.
|
|
if (!NTD->getASTContext().evaluator.hasActiveRequest(
|
|
SynthesizeMemberwiseInitRequest{NTD}))
|
|
TypeChecker::addImplicitConstructors(NTD);
|
|
|
|
// Check all conformances to trigger the synthesized decl generation.
|
|
// e.g. init(rawValue:) for RawRepresentable.
|
|
for (auto Conformance : NTD->getAllConformances()) {
|
|
auto Proto = Conformance->getProtocol();
|
|
if (!Proto->isAccessibleFrom(DC))
|
|
continue;
|
|
auto NormalConformance = dyn_cast<NormalProtocolConformance>(
|
|
Conformance->getRootConformance());
|
|
if (!NormalConformance)
|
|
continue;
|
|
NormalConformance->forEachTypeWitness(
|
|
[](AssociatedTypeDecl *, Type, TypeDecl *) { return false; },
|
|
/*useResolver=*/true);
|
|
NormalConformance->forEachValueWitness([](ValueDecl *, Witness) {},
|
|
/*useResolver=*/true);
|
|
}
|
|
|
|
synthesizePropertyWrapperVariables(NTD);
|
|
}
|
|
|
|
static void lookupVisibleMemberDeclsImpl(
|
|
Type BaseTy, VisibleDeclConsumer &Consumer, const DeclContext *CurrDC,
|
|
LookupState LS, DeclVisibilityKind Reason, GenericSignatureBuilder *GSB,
|
|
VisitedSet &Visited) {
|
|
// Just look through l-valueness. It doesn't affect name lookup.
|
|
assert(BaseTy && "lookup into null type");
|
|
assert(!BaseTy->hasLValueType());
|
|
|
|
// Handle metatype references, as in "some_type.some_member". These are
|
|
// special and can't have extensions.
|
|
if (auto MTT = BaseTy->getAs<AnyMetatypeType>()) {
|
|
// The metatype represents an arbitrary named type: dig through to the
|
|
// declared type to see what we're dealing with.
|
|
Type Ty = MTT->getInstanceType();
|
|
if (auto dynSelfTy = Ty->getAs<DynamicSelfType>())
|
|
Ty = dynSelfTy->getSelfType();
|
|
if (Ty->is<AnyMetatypeType>())
|
|
return;
|
|
|
|
LookupState subLS = LookupState::makeQualified().withOnMetatype();
|
|
if (LS.isIncludingInstanceMembers()) {
|
|
subLS = subLS.withIncludedInstanceMembers();
|
|
}
|
|
if (LS.isIncludingDerivedRequirements()) {
|
|
subLS = subLS.withIncludedDerivedRequirements();
|
|
}
|
|
if (LS.isIncludingProtocolExtensionMembers()) {
|
|
subLS = subLS.withIncludeProtocolExtensionMembers();
|
|
}
|
|
|
|
// Just perform normal dot lookup on the type see if we find extensions or
|
|
// anything else. For example, type SomeTy.SomeMember can look up static
|
|
// functions, and can even look up non-static functions as well (thus
|
|
// getting the address of the member).
|
|
lookupVisibleMemberDeclsImpl(Ty, Consumer, CurrDC, subLS, Reason,
|
|
GSB, Visited);
|
|
return;
|
|
}
|
|
|
|
// Lookup module references, as on some_module.some_member. These are
|
|
// special and can't have extensions.
|
|
if (ModuleType *MT = BaseTy->getAs<ModuleType>()) {
|
|
AccessFilteringDeclConsumer FilteringConsumer(CurrDC, Consumer);
|
|
MT->getModule()->lookupVisibleDecls(ImportPath::Access(),
|
|
FilteringConsumer,
|
|
NLKind::QualifiedLookup);
|
|
return;
|
|
}
|
|
|
|
// If the base is AnyObject, we are doing dynamic lookup.
|
|
if (BaseTy->isAnyObject()) {
|
|
doDynamicLookup(Consumer, CurrDC, LS);
|
|
return;
|
|
}
|
|
|
|
// If the base is a protocol, enumerate its members.
|
|
if (ProtocolType *PT = BaseTy->getAs<ProtocolType>()) {
|
|
lookupVisibleProtocolMemberDecls(BaseTy, PT->getDecl(),
|
|
Consumer, CurrDC, LS, Reason,
|
|
GSB, Visited);
|
|
return;
|
|
}
|
|
|
|
// If the base is a protocol composition, enumerate members of the protocols.
|
|
if (auto PC = BaseTy->getAs<ProtocolCompositionType>()) {
|
|
for (auto Member : PC->getMembers())
|
|
lookupVisibleMemberDeclsImpl(Member, Consumer, CurrDC, LS, Reason,
|
|
GSB, Visited);
|
|
return;
|
|
}
|
|
|
|
// Enumerate members of archetype's requirements.
|
|
if (ArchetypeType *Archetype = BaseTy->getAs<ArchetypeType>()) {
|
|
for (auto Proto : Archetype->getConformsTo())
|
|
lookupVisibleProtocolMemberDecls(
|
|
BaseTy, Proto, Consumer, CurrDC, LS,
|
|
Reason, GSB, Visited);
|
|
|
|
if (auto superclass = Archetype->getSuperclass())
|
|
lookupVisibleMemberDeclsImpl(superclass, Consumer, CurrDC, LS,
|
|
Reason, GSB, Visited);
|
|
return;
|
|
}
|
|
|
|
// If we're looking into a type parameter and we have a generic signature
|
|
// builder, use the GSB to resolve where we should look.
|
|
if (BaseTy->isTypeParameter() && GSB) {
|
|
auto EquivClass =
|
|
GSB->resolveEquivalenceClass(BaseTy,
|
|
ArchetypeResolutionKind::CompleteWellFormed);
|
|
if (!EquivClass) return;
|
|
|
|
if (EquivClass->concreteType) {
|
|
BaseTy = EquivClass->concreteType;
|
|
} else {
|
|
// Conformances
|
|
for (const auto &Conforms : EquivClass->conformsTo) {
|
|
lookupVisibleProtocolMemberDecls(
|
|
BaseTy, Conforms.first, Consumer, CurrDC,
|
|
LS, getReasonForSuper(Reason), GSB, Visited);
|
|
}
|
|
|
|
// Superclass.
|
|
if (EquivClass->superclass) {
|
|
lookupVisibleMemberDeclsImpl(EquivClass->superclass, Consumer, CurrDC,
|
|
LS, getReasonForSuper(Reason),
|
|
GSB, Visited);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
auto lookupTy = BaseTy;
|
|
|
|
const auto synthesizeAndLookupTypeMembers = [&](NominalTypeDecl *NTD) {
|
|
synthesizeMemberDeclsForLookup(NTD, CurrDC);
|
|
|
|
// Look in for members of a nominal type.
|
|
lookupTypeMembers(BaseTy, lookupTy, Consumer, CurrDC, LS, Reason);
|
|
};
|
|
|
|
llvm::SmallPtrSet<ClassDecl *, 8> Ancestors;
|
|
{
|
|
const auto NTD = BaseTy->getAnyNominal();
|
|
if (NTD == nullptr)
|
|
return;
|
|
|
|
synthesizeAndLookupTypeMembers(NTD);
|
|
// Look into protocols only on the current nominal to avoid repeatedly
|
|
// visiting inherited conformances.
|
|
lookupDeclsFromProtocolsBeingConformedTo(BaseTy, Consumer, LS, CurrDC,
|
|
Reason, Visited);
|
|
|
|
const auto CD = dyn_cast<ClassDecl>(NTD);
|
|
|
|
// FIXME: We check `getSuperclass()` here because we'll be using the
|
|
// superclass Type below, and in ill-formed code `hasSuperclass()` could
|
|
// be true while `getSuperclass()` returns null, because the latter
|
|
// looks for a declaration.
|
|
if (!CD || !CD->getSuperclass())
|
|
return;
|
|
|
|
// We have a superclass; switch state and look into the inheritance chain.
|
|
Ancestors.insert(CD);
|
|
|
|
Reason = getReasonForSuper(Reason);
|
|
lookupTy = CD->getSuperclass();
|
|
|
|
LS = LS.withOnSuperclass();
|
|
if (CD->inheritsSuperclassInitializers())
|
|
LS = LS.withInheritsSuperclassInitializers();
|
|
}
|
|
|
|
// Look into the inheritance chain.
|
|
do {
|
|
const auto CurClass = lookupTy->getClassOrBoundGenericClass();
|
|
|
|
// FIXME: This path is no substitute for an actual circularity check.
|
|
// The real fix is to check that the superclass doesn't introduce a
|
|
// circular reference before it's written into the AST.
|
|
if (!Ancestors.insert(CurClass).second)
|
|
break;
|
|
|
|
synthesizeAndLookupTypeMembers(CurClass);
|
|
|
|
lookupTy = CurClass->getSuperclass();
|
|
if (!CurClass->inheritsSuperclassInitializers())
|
|
LS = LS.withoutInheritsSuperclassInitializers();
|
|
} while (lookupTy);
|
|
}
|
|
|
|
swift::DynamicLookupInfo::DynamicLookupInfo(
|
|
SubscriptDecl *subscript, Type baseType,
|
|
DeclVisibilityKind originalVisibility)
|
|
: kind(KeyPathDynamicMember) {
|
|
keypath.subscript = subscript;
|
|
keypath.baseType = baseType;
|
|
keypath.originalVisibility = originalVisibility;
|
|
}
|
|
|
|
const DynamicLookupInfo::KeyPathDynamicMemberInfo &
|
|
swift::DynamicLookupInfo::getKeyPathDynamicMember() const {
|
|
assert(kind == KeyPathDynamicMember);
|
|
return keypath;
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct FoundDeclTy {
|
|
ValueDecl *D;
|
|
DeclVisibilityKind Reason;
|
|
DynamicLookupInfo dynamicLookupInfo;
|
|
|
|
FoundDeclTy(ValueDecl *D, DeclVisibilityKind Reason,
|
|
DynamicLookupInfo dynamicLookupInfo)
|
|
: D(D), Reason(Reason), dynamicLookupInfo(dynamicLookupInfo) {}
|
|
|
|
friend bool operator==(const FoundDeclTy &LHS, const FoundDeclTy &RHS) {
|
|
// If this ever changes - e.g. to include Reason - be sure to also update
|
|
// DenseMapInfo<FoundDeclTy>::getHashValue().
|
|
return LHS.D == RHS.D;
|
|
}
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
namespace llvm {
|
|
|
|
template <> struct DenseMapInfo<FoundDeclTy> {
|
|
static inline FoundDeclTy getEmptyKey() {
|
|
return FoundDeclTy{nullptr, DeclVisibilityKind::LocalVariable, {}};
|
|
}
|
|
|
|
static inline FoundDeclTy getTombstoneKey() {
|
|
return FoundDeclTy{reinterpret_cast<ValueDecl *>(0x1),
|
|
DeclVisibilityKind::LocalVariable,
|
|
{}};
|
|
}
|
|
|
|
static unsigned getHashValue(const FoundDeclTy &Val) {
|
|
// Note: FoundDeclTy::operator== only considers D, so don't hash Reason here.
|
|
return llvm::hash_value(Val.D);
|
|
}
|
|
|
|
static bool isEqual(const FoundDeclTy &LHS, const FoundDeclTy &RHS) {
|
|
return LHS == RHS;
|
|
}
|
|
};
|
|
|
|
} // namespace llvm
|
|
|
|
// If a class 'Base' conforms to 'Proto', and my base type is a subclass
|
|
// 'Derived' of 'Base', use 'Base' not 'Derived' as the 'Self' type in the
|
|
// substitution map.
|
|
static Type getBaseTypeForMember(ModuleDecl *M, const ValueDecl *OtherVD,
|
|
Type BaseTy) {
|
|
if (auto *Proto = OtherVD->getDeclContext()->getSelfProtocolDecl()) {
|
|
if (BaseTy->getClassOrBoundGenericClass()) {
|
|
if (auto Conformance = M->lookupConformance(BaseTy, Proto)) {
|
|
auto *Superclass = Conformance.getConcrete()
|
|
->getRootConformance()
|
|
->getType()
|
|
->getClassOrBoundGenericClass();
|
|
return BaseTy->getSuperclassForDecl(Superclass);
|
|
}
|
|
}
|
|
}
|
|
|
|
return BaseTy;
|
|
}
|
|
|
|
namespace {
|
|
|
|
class OverrideFilteringConsumer : public VisibleDeclConsumer {
|
|
public:
|
|
llvm::SetVector<FoundDeclTy> Results;
|
|
llvm::SmallVector<ValueDecl *, 8> Decls;
|
|
llvm::SetVector<FoundDeclTy> FilteredResults;
|
|
llvm::DenseMap<DeclBaseName, llvm::SmallVector<ValueDecl *, 2>> DeclsByName;
|
|
Type BaseTy;
|
|
const DeclContext *DC;
|
|
|
|
OverrideFilteringConsumer(Type BaseTy, const DeclContext *DC)
|
|
: BaseTy(BaseTy->getMetatypeInstanceType()),
|
|
DC(DC) {
|
|
assert(!BaseTy->hasLValueType());
|
|
assert(DC && BaseTy);
|
|
}
|
|
|
|
void foundDecl(ValueDecl *VD, DeclVisibilityKind Reason,
|
|
DynamicLookupInfo dynamicLookupInfo) override {
|
|
if (!Results.insert({VD, Reason, dynamicLookupInfo}))
|
|
return;
|
|
|
|
DeclsByName[VD->getBaseName()] = {};
|
|
Decls.push_back(VD);
|
|
}
|
|
|
|
void filterDecls(VisibleDeclConsumer &Consumer) {
|
|
removeOverriddenDecls(Decls);
|
|
removeShadowedDecls(Decls, DC);
|
|
|
|
size_t index = 0;
|
|
for (const auto &DeclAndReason : Results) {
|
|
if (index >= Decls.size())
|
|
break;
|
|
if (DeclAndReason.D != Decls[index])
|
|
continue;
|
|
|
|
++index;
|
|
|
|
auto *const VD = DeclAndReason.D;
|
|
const auto Reason = DeclAndReason.Reason;
|
|
|
|
// If this kind of declaration doesn't participate in overriding, there's
|
|
// no filtering to do here.
|
|
if (!isa<AbstractFunctionDecl>(VD) &&
|
|
!isa<AbstractStorageDecl>(VD) &&
|
|
!isa<AssociatedTypeDecl>(VD)) {
|
|
FilteredResults.insert(DeclAndReason);
|
|
continue;
|
|
}
|
|
|
|
if (VD->isRecursiveValidation())
|
|
continue;
|
|
|
|
auto &PossiblyConflicting = DeclsByName[VD->getBaseName()];
|
|
|
|
if (VD->isInvalid()) {
|
|
FilteredResults.insert(DeclAndReason);
|
|
PossiblyConflicting.push_back(VD);
|
|
continue;
|
|
}
|
|
|
|
// Does it make sense to substitute types?
|
|
|
|
// If the base type is AnyObject, we might be doing a dynamic
|
|
// lookup, so the base type won't match the type of the member's
|
|
// context type.
|
|
//
|
|
// If the base type is not a nominal type, we can't substitute
|
|
// the member type.
|
|
//
|
|
// If the member is a free function and not a member of a type,
|
|
// don't substitute either.
|
|
bool shouldSubst = (Reason != DeclVisibilityKind::DynamicLookup &&
|
|
!BaseTy->isAnyObject() && !BaseTy->hasTypeVariable() &&
|
|
!BaseTy->hasUnboundGenericType() &&
|
|
(BaseTy->getNominalOrBoundGenericNominal() ||
|
|
BaseTy->is<ArchetypeType>()) &&
|
|
VD->getDeclContext()->isTypeContext());
|
|
ModuleDecl *M = DC->getParentModule();
|
|
|
|
auto FoundSignature = VD->getOverloadSignature();
|
|
auto FoundSignatureType = VD->getOverloadSignatureType();
|
|
if (FoundSignatureType && shouldSubst) {
|
|
auto subs = BaseTy->getMemberSubstitutionMap(M, VD);
|
|
auto CT = FoundSignatureType.subst(subs);
|
|
if (!CT->hasError())
|
|
FoundSignatureType = CT->getCanonicalType();
|
|
}
|
|
|
|
bool FoundConflicting = false;
|
|
for (auto I = PossiblyConflicting.begin(), E = PossiblyConflicting.end();
|
|
I != E; ++I) {
|
|
auto *const OtherVD = *I;
|
|
if (OtherVD->isRecursiveValidation())
|
|
continue;
|
|
|
|
if (OtherVD->isInvalid())
|
|
continue;
|
|
|
|
auto OtherSignature = OtherVD->getOverloadSignature();
|
|
auto OtherSignatureType = OtherVD->getOverloadSignatureType();
|
|
if (OtherSignatureType && shouldSubst) {
|
|
auto ActualBaseTy = getBaseTypeForMember(M, OtherVD, BaseTy);
|
|
auto subs = ActualBaseTy->getMemberSubstitutionMap(M, OtherVD);
|
|
auto CT = OtherSignatureType.subst(subs);
|
|
if (!CT->hasError())
|
|
OtherSignatureType = CT->getCanonicalType();
|
|
}
|
|
|
|
if (conflicting(M->getASTContext(), FoundSignature, FoundSignatureType,
|
|
OtherSignature, OtherSignatureType,
|
|
/*wouldConflictInSwift5*/nullptr,
|
|
/*skipProtocolExtensionCheck*/true)) {
|
|
FoundConflicting = true;
|
|
|
|
if (!AvailableAttr::isUnavailable(VD)) {
|
|
bool preferVD = (
|
|
// Prefer derived requirements over their witnesses.
|
|
Reason == DeclVisibilityKind::
|
|
MemberOfProtocolDerivedByCurrentNominal ||
|
|
// Prefer available one.
|
|
AvailableAttr::isUnavailable(OtherVD) ||
|
|
// Prefer more accessible one.
|
|
VD->getFormalAccess() > OtherVD->getFormalAccess());
|
|
if (preferVD) {
|
|
FilteredResults.remove(
|
|
FoundDeclTy(OtherVD, DeclVisibilityKind::LocalVariable, {}));
|
|
FilteredResults.insert(DeclAndReason);
|
|
*I = VD;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!FoundConflicting) {
|
|
FilteredResults.insert(DeclAndReason);
|
|
PossiblyConflicting.push_back(VD);
|
|
}
|
|
}
|
|
|
|
for (auto Result : FilteredResults)
|
|
Consumer.foundDecl(Result.D, Result.Reason, Result.dynamicLookupInfo);
|
|
}
|
|
|
|
bool seenBaseName(DeclBaseName name) {
|
|
return DeclsByName.find(name) != DeclsByName.end();
|
|
}
|
|
};
|
|
|
|
struct KeyPathDynamicMemberConsumer : public VisibleDeclConsumer {
|
|
VisibleDeclConsumer &consumer;
|
|
std::function<bool(DeclBaseName)> seenStaticBaseName;
|
|
llvm::DenseSet<DeclBaseName> seen;
|
|
|
|
SubscriptDecl *currentSubscript = nullptr;
|
|
Type currentBaseType = Type();
|
|
|
|
KeyPathDynamicMemberConsumer(VisibleDeclConsumer &consumer,
|
|
std::function<bool(DeclBaseName)> seenBaseName)
|
|
: consumer(consumer), seenStaticBaseName(std::move(seenBaseName)) {}
|
|
|
|
bool checkShadowed(ValueDecl *VD) {
|
|
// Dynamic lookup members are only visible if they are not shadowed by
|
|
// other members.
|
|
return !isa<SubscriptDecl>(VD) && seen.insert(VD->getBaseName()).second &&
|
|
!seenStaticBaseName(VD->getBaseName());
|
|
}
|
|
|
|
void foundDecl(ValueDecl *VD, DeclVisibilityKind reason,
|
|
DynamicLookupInfo dynamicLookupInfo) override {
|
|
assert(dynamicLookupInfo.getKind() !=
|
|
DynamicLookupInfo::KeyPathDynamicMember);
|
|
|
|
// Only variables and subscripts are allowed in a keypath.
|
|
if (!isa<AbstractStorageDecl>(VD))
|
|
return;
|
|
|
|
// Dynamic lookup members are only visible if they are not shadowed by
|
|
// non-dynamic members.
|
|
if (checkShadowed(VD))
|
|
consumer.foundDecl(VD, DeclVisibilityKind::DynamicLookup,
|
|
{currentSubscript, currentBaseType, reason});
|
|
}
|
|
|
|
struct SubscriptChange {
|
|
KeyPathDynamicMemberConsumer &consumer;
|
|
SubscriptDecl *oldSubscript;
|
|
Type oldBaseType;
|
|
|
|
SubscriptChange(KeyPathDynamicMemberConsumer &consumer,
|
|
SubscriptDecl *newSubscript, Type newBaseType)
|
|
: consumer(consumer), oldSubscript(newSubscript),
|
|
oldBaseType(newBaseType) {
|
|
std::swap(consumer.currentSubscript, oldSubscript);
|
|
std::swap(consumer.currentBaseType, oldBaseType);
|
|
}
|
|
~SubscriptChange() {
|
|
consumer.currentSubscript = oldSubscript;
|
|
consumer.currentBaseType = oldBaseType;
|
|
}
|
|
};
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
static void lookupVisibleDynamicMemberLookupDecls(
|
|
Type baseType, KeyPathDynamicMemberConsumer &consumer,
|
|
const DeclContext *dc, LookupState LS, DeclVisibilityKind reason,
|
|
GenericSignatureBuilder *GSB, VisitedSet &visited,
|
|
llvm::DenseSet<TypeBase *> &seenDynamicLookup);
|
|
|
|
/// Enumerates all members of \c baseType, including both directly visible and
|
|
/// members visible by keypath dynamic member lookup.
|
|
///
|
|
/// \note This is an implementation detail of \c lookupVisibleMemberDecls and
|
|
/// exists to create the correct recursion for dynamic member lookup.
|
|
static void lookupVisibleMemberAndDynamicMemberDecls(
|
|
Type baseType, VisibleDeclConsumer &consumer,
|
|
KeyPathDynamicMemberConsumer &dynamicMemberConsumer, const DeclContext *DC,
|
|
LookupState LS, DeclVisibilityKind reason, GenericSignatureBuilder *GSB,
|
|
VisitedSet &visited, llvm::DenseSet<TypeBase *> &seenDynamicLookup) {
|
|
lookupVisibleMemberDeclsImpl(baseType, consumer, DC, LS, reason, GSB, visited);
|
|
lookupVisibleDynamicMemberLookupDecls(baseType, dynamicMemberConsumer, DC, LS,
|
|
reason, GSB, visited, seenDynamicLookup);
|
|
}
|
|
|
|
/// Enumerates all keypath dynamic members of \c baseType, as seen from the
|
|
/// context \c dc.
|
|
///
|
|
/// If \c baseType is \c \@dynamicMemberLookup, this looks up any keypath
|
|
/// dynamic member subscripts and looks up the members of the keypath's root
|
|
/// type.
|
|
static void lookupVisibleDynamicMemberLookupDecls(
|
|
Type baseType, KeyPathDynamicMemberConsumer &consumer,
|
|
const DeclContext *dc, LookupState LS, DeclVisibilityKind reason,
|
|
GenericSignatureBuilder *GSB, VisitedSet &visited,
|
|
llvm::DenseSet<TypeBase *> &seenDynamicLookup) {
|
|
if (!seenDynamicLookup.insert(baseType.getPointer()).second)
|
|
return;
|
|
|
|
if (!baseType->hasDynamicMemberLookupAttribute())
|
|
return;
|
|
|
|
auto &ctx = dc->getASTContext();
|
|
|
|
// Lookup the `subscript(dynamicMember:)` methods in this type.
|
|
DeclNameRef subscriptName(
|
|
{ ctx, DeclBaseName::createSubscript(), { ctx.Id_dynamicMember} });
|
|
|
|
SmallVector<ValueDecl *, 2> subscripts;
|
|
dc->lookupQualified(baseType, subscriptName, NL_QualifiedDefault,
|
|
subscripts);
|
|
|
|
for (ValueDecl *VD : subscripts) {
|
|
auto *subscript = dyn_cast<SubscriptDecl>(VD);
|
|
if (!subscript)
|
|
continue;
|
|
|
|
auto rootType = evaluateOrDefault(subscript->getASTContext().evaluator,
|
|
RootTypeOfKeypathDynamicMemberRequest{subscript}, Type());
|
|
if (rootType.isNull())
|
|
continue;
|
|
|
|
auto subs =
|
|
baseType->getMemberSubstitutionMap(dc->getParentModule(), subscript);
|
|
auto memberType = rootType.subst(subs);
|
|
if (!memberType->mayHaveMembers())
|
|
continue;
|
|
|
|
KeyPathDynamicMemberConsumer::SubscriptChange sub(consumer, subscript,
|
|
baseType);
|
|
|
|
lookupVisibleMemberAndDynamicMemberDecls(memberType, consumer, consumer, dc,
|
|
LS, reason, GSB, visited,
|
|
seenDynamicLookup);
|
|
}
|
|
}
|
|
|
|
/// Enumerate all members in \c BaseTy (including members of extensions,
|
|
/// superclasses and implemented protocols), as seen from the context \c CurrDC.
|
|
///
|
|
/// This operation corresponds to a standard "dot" lookup operation like "a.b"
|
|
/// where 'self' is the type of 'a'. This operation is only valid after name
|
|
/// binding.
|
|
static void lookupVisibleMemberDecls(
|
|
Type BaseTy, VisibleDeclConsumer &Consumer, const DeclContext *CurrDC,
|
|
LookupState LS, DeclVisibilityKind Reason, GenericSignatureBuilder *GSB) {
|
|
OverrideFilteringConsumer overrideConsumer(BaseTy, CurrDC);
|
|
KeyPathDynamicMemberConsumer dynamicConsumer(
|
|
Consumer,
|
|
[&](DeclBaseName name) { return overrideConsumer.seenBaseName(name); });
|
|
|
|
VisitedSet Visited;
|
|
llvm::DenseSet<TypeBase *> seenDynamicLookup;
|
|
lookupVisibleMemberAndDynamicMemberDecls(
|
|
BaseTy, overrideConsumer, dynamicConsumer, CurrDC, LS, Reason,
|
|
GSB, Visited, seenDynamicLookup);
|
|
|
|
// Report the declarations we found to the real consumer.
|
|
overrideConsumer.filterDecls(Consumer);
|
|
}
|
|
|
|
static void lookupVisibleDeclsImpl(VisibleDeclConsumer &Consumer,
|
|
const DeclContext *DC,
|
|
bool IncludeTopLevel, SourceLoc Loc) {
|
|
const SourceManager &SM = DC->getASTContext().SourceMgr;
|
|
auto Reason = DeclVisibilityKind::MemberOfCurrentNominal;
|
|
|
|
// If we are inside of a method, check to see if there are any ivars in scope,
|
|
// and if so, whether this is a reference to one of them.
|
|
while (!DC->isModuleScopeContext()) {
|
|
GenericParamList *GenericParams = nullptr;
|
|
Type ExtendedType;
|
|
auto LS = LookupState::makeUnqualified();
|
|
LS = LS.withIncludeProtocolExtensionMembers();
|
|
|
|
// Skip initializer contexts, we will not find any declarations there.
|
|
if (isa<Initializer>(DC)) {
|
|
// For non-'lazy' decls, lookup on the meta type.
|
|
if (!isa<PatternBindingInitializer>(DC) ||
|
|
!cast<PatternBindingInitializer>(DC)->getInitializedLazyVar())
|
|
LS = LS.withOnMetatype();
|
|
DC = DC->getParent();
|
|
}
|
|
|
|
// We don't look for generic parameters if we are in the context of a
|
|
// nominal type: they will be looked up anyways via `lookupVisibleMemberDecls`.
|
|
if (DC && !isa<NominalTypeDecl>(DC)) {
|
|
if (auto *decl = DC->getAsDecl()) {
|
|
if (auto GC = decl->getAsGenericContext()) {
|
|
auto params = GC->getGenericParams();
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).checkGenericParams(params);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (auto *SE = dyn_cast<SubscriptDecl>(DC)) {
|
|
ExtendedType = SE->getDeclContext()->getSelfTypeInContext();
|
|
DC = DC->getParent();
|
|
if (SE->isStatic())
|
|
LS = LS.withOnMetatype();
|
|
} else if (auto *AFD = dyn_cast<AbstractFunctionDecl>(DC)) {
|
|
|
|
// Look for local variables; normally, the parser resolves these
|
|
// for us, but it can't do the right thing inside local types.
|
|
// FIXME: when we can parse and typecheck the function body partially for
|
|
// code completion, AFD->getBody() check can be removed.
|
|
if (Loc.isValid() &&
|
|
AFD->getBodySourceRange().isValid() &&
|
|
SM.rangeContainsTokenLoc(AFD->getBodySourceRange(), Loc) &&
|
|
AFD->getBody()) {
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).visit(AFD->getBody());
|
|
}
|
|
|
|
if (auto *P = AFD->getImplicitSelfDecl()) {
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).checkValueDecl(
|
|
const_cast<ParamDecl *>(P), DeclVisibilityKind::FunctionParameter);
|
|
}
|
|
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).checkParameterList(
|
|
AFD->getParameters());
|
|
|
|
GenericParams = AFD->getGenericParams();
|
|
|
|
if (AFD->getDeclContext()->isTypeContext()) {
|
|
ExtendedType = AFD->getDeclContext()->getSelfTypeInContext();
|
|
DC = DC->getParent();
|
|
|
|
if (auto *FD = dyn_cast<FuncDecl>(AFD))
|
|
if (FD->isStatic())
|
|
LS = LS.withOnMetatype();
|
|
}
|
|
} else if (auto CE = dyn_cast<ClosureExpr>(DC)) {
|
|
if (Loc.isValid()) {
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).visit(CE->getBody());
|
|
if (auto P = CE->getParameters()) {
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).checkParameterList(P);
|
|
}
|
|
}
|
|
} else if (auto ED = dyn_cast<ExtensionDecl>(DC)) {
|
|
ExtendedType = ED->getSelfTypeInContext();
|
|
} else if (auto ND = dyn_cast<NominalTypeDecl>(DC)) {
|
|
ExtendedType = ND->getSelfTypeInContext();
|
|
}
|
|
|
|
// If we're inside a function context, we've already moved to
|
|
// the parent DC, so we have to check the function's generic
|
|
// parameters first.
|
|
if (GenericParams) {
|
|
namelookup::FindLocalVal localVal(SM, Loc, Consumer);
|
|
localVal.checkGenericParams(GenericParams);
|
|
}
|
|
|
|
// Check the generic parameters of our context.
|
|
GenericParamList *dcGenericParams = nullptr;
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(DC))
|
|
dcGenericParams = nominal->getGenericParams();
|
|
else if (auto ext = dyn_cast<ExtensionDecl>(DC))
|
|
dcGenericParams = ext->getGenericParams();
|
|
else if (auto subscript = dyn_cast<SubscriptDecl>(DC))
|
|
dcGenericParams = subscript->getGenericParams();
|
|
|
|
while (dcGenericParams) {
|
|
namelookup::FindLocalVal localVal(SM, Loc, Consumer);
|
|
localVal.checkGenericParams(dcGenericParams);
|
|
dcGenericParams = dcGenericParams->getOuterParameters();
|
|
}
|
|
|
|
if (ExtendedType)
|
|
::lookupVisibleMemberDecls(ExtendedType, Consumer, DC, LS, Reason,
|
|
nullptr);
|
|
|
|
DC = DC->getParent();
|
|
Reason = DeclVisibilityKind::MemberOfOutsideNominal;
|
|
}
|
|
|
|
if (auto SF = dyn_cast<SourceFile>(DC)) {
|
|
if (Loc.isValid()) {
|
|
// Look for local variables in top-level code; normally, the parser
|
|
// resolves these for us, but it can't do the right thing for
|
|
// local types.
|
|
namelookup::FindLocalVal(SM, Loc, Consumer).checkSourceFile(*SF);
|
|
}
|
|
|
|
if (IncludeTopLevel) {
|
|
auto &cached = SF->getCachedVisibleDecls();
|
|
if (!cached.empty()) {
|
|
for (auto result : cached)
|
|
Consumer.foundDecl(result, DeclVisibilityKind::VisibleAtTopLevel);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IncludeTopLevel) {
|
|
using namespace namelookup;
|
|
SmallVector<ValueDecl *, 0> moduleResults;
|
|
lookupVisibleDeclsInModule(DC, {}, moduleResults,
|
|
NLKind::UnqualifiedLookup,
|
|
ResolutionKind::Overloadable,
|
|
DC);
|
|
for (auto result : moduleResults)
|
|
Consumer.foundDecl(result, DeclVisibilityKind::VisibleAtTopLevel);
|
|
|
|
if (auto SF = dyn_cast<SourceFile>(DC))
|
|
SF->cacheVisibleDecls(std::move(moduleResults));
|
|
}
|
|
}
|
|
|
|
void swift::lookupVisibleDecls(VisibleDeclConsumer &Consumer,
|
|
const DeclContext *DC,
|
|
bool IncludeTopLevel,
|
|
SourceLoc Loc) {
|
|
if (Loc.isInvalid()) {
|
|
lookupVisibleDeclsImpl(Consumer, DC, IncludeTopLevel, Loc);
|
|
return;
|
|
}
|
|
|
|
// Filtering out unusable values.
|
|
class LocalConsumer : public VisibleDeclConsumer {
|
|
const SourceManager &SM;
|
|
SourceLoc Loc;
|
|
VisibleDeclConsumer &Consumer;
|
|
|
|
bool isUsableValue(ValueDecl *VD, DeclVisibilityKind Reason) {
|
|
|
|
// Check "use within its own initial value" case.
|
|
if (auto *varD = dyn_cast<VarDecl>(VD)) {
|
|
if (auto *initExpr = varD->getParentInitializer())
|
|
if (SM.rangeContainsTokenLoc(initExpr->getSourceRange(), Loc))
|
|
return false;
|
|
}
|
|
|
|
switch (Reason) {
|
|
case DeclVisibilityKind::LocalVariable:
|
|
// Use of 'TypeDecl's before declaration is allowed.
|
|
if (isa<TypeDecl>(VD))
|
|
return true;
|
|
|
|
return SM.isBeforeInBuffer(VD->getLoc(), Loc);
|
|
|
|
case DeclVisibilityKind::VisibleAtTopLevel:
|
|
// TODO: Implement forward reference rule for script mode? Currently,
|
|
// it's not needed because the rest of the file hasn't been parsed.
|
|
// See: https://bugs.swift.org/browse/SR-284 for the rule.
|
|
return true;
|
|
|
|
default:
|
|
// Other visibility kind are always usable.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public:
|
|
LocalConsumer(const SourceManager &SM, SourceLoc Loc,
|
|
VisibleDeclConsumer &Consumer)
|
|
: SM(SM), Loc(Loc), Consumer(Consumer) {}
|
|
|
|
void foundDecl(ValueDecl *VD, DeclVisibilityKind Reason,
|
|
DynamicLookupInfo dynamicLookupInfo) override {
|
|
if (isUsableValue(VD, Reason))
|
|
Consumer.foundDecl(VD, Reason, dynamicLookupInfo);
|
|
}
|
|
} LocalConsumer(DC->getASTContext().SourceMgr, Loc, Consumer);
|
|
|
|
lookupVisibleDeclsImpl(LocalConsumer, DC, IncludeTopLevel, Loc);
|
|
}
|
|
|
|
void swift::lookupVisibleMemberDecls(VisibleDeclConsumer &Consumer, Type BaseTy,
|
|
const DeclContext *CurrDC,
|
|
bool includeInstanceMembers,
|
|
bool includeDerivedRequirements,
|
|
bool includeProtocolExtensionMembers,
|
|
GenericSignatureBuilder *GSB) {
|
|
assert(CurrDC);
|
|
LookupState ls = LookupState::makeQualified();
|
|
if (includeInstanceMembers) {
|
|
ls = ls.withIncludedInstanceMembers();
|
|
}
|
|
if (includeDerivedRequirements) {
|
|
ls = ls.withIncludedDerivedRequirements();
|
|
}
|
|
if (includeProtocolExtensionMembers) {
|
|
ls = ls.withIncludeProtocolExtensionMembers();
|
|
}
|
|
|
|
::lookupVisibleMemberDecls(BaseTy, Consumer, CurrDC, ls,
|
|
DeclVisibilityKind::MemberOfCurrentNominal,
|
|
GSB);
|
|
}
|