GenericEnvironment::GenericEnvironment(
TypeSubstitutionMap interfaceToArchetypeMap) {
assert(!interfaceToArchetypeMap.empty());
// Build a mapping in both directions, making sure to canonicalize the
// interface type where it is used as a key, so that substitution can
// find them, and to preserve sugar otherwise, so that
// mapTypeOutOfContext() produces a human-readable type.
for (auto entry : interfaceToArchetypeMap) {
// We're going to pass InterfaceToArchetypeMap to Type::subst(), which
// expects the keys to be canonical, otherwise it won't be able to
// find them.
auto canParamTy = cast<GenericTypeParamType>(entry.first->getCanonicalType());
auto contextTy = entry.second;
auto result = InterfaceToArchetypeMap.insert(
std::make_pair(canParamTy, contextTy));
assert(result.second && "duplicate generic parameters in environment");
// If we mapped the generic parameter to an archetype, add it to the
// reverse mapping.
if (auto *archetypeTy = entry.second->getAs<ArchetypeType>())
ArchetypeToInterfaceMap[archetypeTy] = entry.first;
// FIXME: If multiple generic parameters map to the same archetype,
// the reverse mapping order is not deterministic.
}
}
/// Create a text string that describes the bindings of generic parameters that
/// are relevant to the given set of types, e.g., "[with T = Bar, U = Wibble]".
///
/// \param types The types that will be scanned for generic type parameters,
/// which will be used in the resulting type.
///
/// \param genericSig The actual generic parameters, whose names will be used
/// in the resulting text.
///
/// \param substitutions The generic parameter -> generic argument substitutions
/// that will have been applied to these types. These are used to produce the
/// "parameter = argument" bindings in the test.
static std::string gatherGenericParamBindingsText(
ArrayRef<Type> types,
GenericSignature *genericSig,
const TypeSubstitutionMap &substitutions) {
llvm::SmallPtrSet<GenericTypeParamType *, 2> knownGenericParams;
for (auto type : types) {
type.visit([&](Type type) {
if (auto gp = type->getAs<GenericTypeParamType>()) {
knownGenericParams.insert(gp->getCanonicalType()
->castTo<GenericTypeParamType>());
}
});
}
if (knownGenericParams.empty())
return "";
SmallString<128> result;
for (auto gp : genericSig->getGenericParams()) {
auto canonGP = gp->getCanonicalType()->castTo<GenericTypeParamType>();
if (!knownGenericParams.count(canonGP))
continue;
if (result.empty())
result += " [with ";
else
result += ", ";
result += gp->getName().str();
result += " = ";
auto found = substitutions.find(canonGP);
if (found == substitutions.end())
return "";
result += found->second.getString();
}
result += "]";
return result.str().str();
}
/// \brief Inlines all mandatory inlined functions into the body of a function,
/// first recursively inlining all mandatory apply instructions in those
/// functions into their bodies if necessary.
///
/// \param F the function to be processed
/// \param AI nullptr if this is being called from the top level; the relevant
/// ApplyInst requiring the recursive call when non-null
/// \param FullyInlinedSet the set of all functions already known to be fully
/// processed, to avoid processing them over again
/// \param SetFactory an instance of ImmutableFunctionSet::Factory
/// \param CurrentInliningSet the set of functions currently being inlined in
/// the current call stack of recursive calls
///
/// \returns true if successful, false if failed due to circular inlining.
static bool
runOnFunctionRecursively(SILFunction *F, FullApplySite AI,
SILModule::LinkingMode Mode,
DenseFunctionSet &FullyInlinedSet,
ImmutableFunctionSet::Factory &SetFactory,
ImmutableFunctionSet CurrentInliningSet,
ClassHierarchyAnalysis *CHA) {
// Avoid reprocessing functions needlessly.
if (FullyInlinedSet.count(F))
return true;
// Prevent attempt to circularly inline.
if (CurrentInliningSet.contains(F)) {
// This cannot happen on a top-level call, so AI should be non-null.
assert(AI && "Cannot have circular inline without apply");
SILLocation L = AI.getLoc();
assert(L && "Must have location for transparent inline apply");
diagnose(F->getModule().getASTContext(), L.getStartSourceLoc(),
diag::circular_transparent);
return false;
}
// Add to the current inlining set (immutably, so we only affect the set
// during this call and recursive subcalls).
CurrentInliningSet = SetFactory.add(CurrentInliningSet, F);
SmallVector<SILValue, 16> CaptureArgs;
SmallVector<SILValue, 32> FullArgs;
for (auto FI = F->begin(), FE = F->end(); FI != FE; ++FI) {
for (auto I = FI->begin(), E = FI->end(); I != E; ++I) {
FullApplySite InnerAI = FullApplySite::isa(&*I);
if (!InnerAI)
continue;
auto *ApplyBlock = InnerAI.getParent();
auto NewInstPair = tryDevirtualizeApply(InnerAI, CHA);
if (auto *NewInst = NewInstPair.first) {
replaceDeadApply(InnerAI, NewInst);
if (auto *II = dyn_cast<SILInstruction>(NewInst))
I = II->getIterator();
else
I = NewInst->getParentBB()->begin();
auto NewAI = FullApplySite::isa(NewInstPair.second.getInstruction());
if (!NewAI)
continue;
InnerAI = NewAI;
}
SILLocation Loc = InnerAI.getLoc();
SILValue CalleeValue = InnerAI.getCallee();
bool IsThick;
PartialApplyInst *PAI;
SILFunction *CalleeFunction = getCalleeFunction(InnerAI, IsThick,
CaptureArgs, FullArgs,
PAI,
Mode);
if (!CalleeFunction ||
CalleeFunction->isTransparent() == IsNotTransparent)
continue;
// Then recursively process it first before trying to inline it.
if (!runOnFunctionRecursively(CalleeFunction, InnerAI, Mode,
FullyInlinedSet, SetFactory,
CurrentInliningSet, CHA)) {
// If we failed due to circular inlining, then emit some notes to
// trace back the failure if we have more information.
// FIXME: possibly it could be worth recovering and attempting other
// inlines within this same recursive call rather than simply
// propagating the failure.
if (AI) {
SILLocation L = AI.getLoc();
assert(L && "Must have location for transparent inline apply");
diagnose(F->getModule().getASTContext(), L.getStartSourceLoc(),
diag::note_while_inlining);
}
return false;
}
// Inline function at I, which also changes I to refer to the first
// instruction inlined in the case that it succeeds. We purposely
// process the inlined body after inlining, because the inlining may
// have exposed new inlining opportunities beyond those present in
// the inlined function when processed independently.
DEBUG(llvm::errs() << "Inlining @" << CalleeFunction->getName()
<< " into @" << InnerAI.getFunction()->getName()
<< "\n");
// Decrement our iterator (carefully, to avoid going off the front) so it
// is valid after inlining is done. Inlining deletes the apply, and can
// introduce multiple new basic blocks.
if (I != ApplyBlock->begin())
--I;
else
I = ApplyBlock->end();
TypeSubstitutionMap ContextSubs;
std::vector<Substitution> ApplySubs(InnerAI.getSubstitutions());
if (PAI) {
auto PAISubs = PAI->getSubstitutions();
ApplySubs.insert(ApplySubs.end(), PAISubs.begin(), PAISubs.end());
}
ContextSubs.copyFrom(CalleeFunction->getContextGenericParams()
->getSubstitutionMap(ApplySubs));
SILInliner Inliner(*F, *CalleeFunction,
SILInliner::InlineKind::MandatoryInline,
ContextSubs, ApplySubs);
if (!Inliner.inlineFunction(InnerAI, FullArgs)) {
I = InnerAI.getInstruction()->getIterator();
continue;
}
// Inlining was successful. Remove the apply.
InnerAI.getInstruction()->eraseFromParent();
// Reestablish our iterator if it wrapped.
if (I == ApplyBlock->end())
I = ApplyBlock->begin();
else
++I;
// If the inlined apply was a thick function, then we need to balance the
// reference counts for correctness.
if (IsThick)
fixupReferenceCounts(I, Loc, CalleeValue, CaptureArgs);
// Now that the IR is correct, see if we can remove dead callee
// computations (e.g. dead partial_apply closures).
cleanupCalleeValue(CalleeValue, CaptureArgs, FullArgs);
// Reposition iterators possibly invalidated by mutation.
FI = SILFunction::iterator(ApplyBlock);
I = ApplyBlock->begin();
E = ApplyBlock->end();
++NumMandatoryInlines;
}
}
// Keep track of full inlined functions so we don't waste time recursively
// reprocessing them.
FullyInlinedSet.insert(F);
return true;
}
/// Determine how close an argument list is to an already decomposed argument
/// list. If the closeness is a miss by a single argument, then this returns
/// information about that failure.
CalleeCandidateInfo::ClosenessResultTy
CalleeCandidateInfo::evaluateCloseness(UncurriedCandidate candidate,
ArrayRef<AnyFunctionType::Param> actualArgs) {
auto *dc = candidate.getDecl()
? candidate.getDecl()->getInnermostDeclContext()
: nullptr;
if (!candidate.hasParameters())
return {CC_GeneralMismatch, {}};
auto candArgs = candidate.getParameters();
llvm::SmallBitVector candDefaultMap =
computeDefaultMap(candArgs, candidate.getDecl(), candidate.level);
struct OurListener : public MatchCallArgumentListener {
CandidateCloseness result = CC_ExactMatch;
public:
CandidateCloseness getResult() const {
return result;
}
void extraArgument(unsigned argIdx) override {
result = CC_ArgumentCountMismatch;
}
void missingArgument(unsigned paramIdx) override {
result = CC_ArgumentCountMismatch;
}
void missingLabel(unsigned paramIdx) override {
result = CC_ArgumentLabelMismatch;
}
void outOfOrderArgument(unsigned argIdx, unsigned prevArgIdx) override {
result = CC_ArgumentLabelMismatch;
}
bool relabelArguments(ArrayRef<Identifier> newNames) override {
result = CC_ArgumentLabelMismatch;
return true;
}
} listener;
// Use matchCallArguments to determine how close the argument list is (in
// shape) to the specified candidates parameters. This ignores the concrete
// types of the arguments, looking only at the argument labels etc.
SmallVector<ParamBinding, 4> paramBindings;
if (matchCallArguments(actualArgs, candArgs,
candDefaultMap,
hasTrailingClosure,
/*allowFixes:*/ true,
listener, paramBindings))
// On error, get our closeness from whatever problem the listener saw.
return { listener.getResult(), {}};
// If we found a mapping, check to see if the matched up arguments agree in
// their type and count the number of mismatched arguments.
unsigned mismatchingArgs = 0;
// Known mapping of archetypes in all arguments so far. An archetype may map
// to another archetype if the constraint system substituted one for another.
TypeSubstitutionMap allGenericSubstitutions;
// Number of args of one generic archetype which are mismatched because
// isSubstitutableFor() has failed. If all mismatches are of this type, we'll
// return a different closeness for better diagnoses.
Type nonSubstitutableArchetype = nullptr;
unsigned nonSubstitutableArgs = 0;
// The type of failure is that multiple occurrences of the same generic are
// being passed arguments with different concrete types.
bool genericWithDifferingConcreteTypes = false;
// We classify an argument mismatch as being a "near" miss if it is a very
// likely match due to a common sort of problem (e.g. wrong flags on a
// function type, optional where none was expected, etc). This allows us to
// heuristically filter large overload sets better.
bool mismatchesAreNearMisses = true;
CalleeCandidateInfo::FailedArgumentInfo failureInfo;
// Local function which extracts type from the parameter container.
auto getParamResultType = [](const AnyFunctionType::Param ¶m) -> Type {
// If parameter is marked as @autoclosure, we are
// only interested in it's resulting type.
if (param.isAutoClosure()) {
if (auto fnType = param.getType()->getAs<AnyFunctionType>())
return fnType->getResult();
}
return param.getType();
};
for (unsigned i = 0, e = paramBindings.size(); i != e; ++i) {
// Bindings specify the arguments that source the parameter. The only case
// this returns a non-singular value is when there are varargs in play.
auto &bindings = paramBindings[i];
auto param = candArgs[i];
auto paramType = getParamResultType(param);
for (auto argNo : bindings) {
auto argType = getParamResultType(actualArgs[argNo]);
auto rArgType = argType->getRValueType();
// FIXME: Right now, a "matching" overload is one with a parameter whose
// type is identical to the argument type, or substitutable via handling
// of functions with primary archetypes in one or more parameters.
// We can still do something more sophisticated with this.
// FIXME: Use TC.isConvertibleTo?
TypeSubstitutionMap archetypesMap;
bool matched;
if (paramType->hasUnresolvedType())
matched = true;
else if (rArgType->hasTypeVariable() || rArgType->hasUnresolvedType())
matched = false;
else {
auto matchType = paramType;
// If the parameter is an inout type, and we have a proper lvalue, match
// against the type contained therein.
if (param.isInOut() && argType->is<LValueType>())
matchType = matchType->getInOutObjectType();
if (candidate.substituted) {
matchType.findIf([&](Type type) -> bool {
// If the replacement is itself an archetype, then the constraint
// system was asserting equivalencies between different levels of
// generics, rather than binding a generic to a concrete type (and we
// don't/won't have a concrete type). In which case, it is the
// replacement we are interested in, since it is the one in our current
// context. That generic type should equal itself.
if (auto archetype = type->getAs<ArchetypeType>()) {
archetypesMap[archetype] = archetype;
}
return false;
});
}
matched = findGenericSubstitutions(dc, matchType, rArgType,
archetypesMap);
}
if (matched) {
for (auto pair : archetypesMap) {
auto archetype = pair.first->castTo<ArchetypeType>();
auto substitution = pair.second;
auto existingSubstitution = allGenericSubstitutions[archetype];
if (!existingSubstitution) {
// New substitution for this callee.
allGenericSubstitutions[archetype] = substitution;
// Not yet handling nested archetypes.
if (!archetype->isPrimary())
return { CC_ArgumentMismatch, {}};
if (!isSubstitutableFor(substitution, archetype, CS.DC)) {
// If we have multiple non-substitutable types, this is just a mismatched mess.
if (!nonSubstitutableArchetype.isNull())
return { CC_ArgumentMismatch, {}};
if (auto argOptType = argType->getOptionalObjectType())
mismatchesAreNearMisses &=
isSubstitutableFor(argOptType, archetype, CS.DC);
else
mismatchesAreNearMisses = false;
nonSubstitutableArchetype = archetype;
nonSubstitutableArgs = 1;
matched = false;
}
} else {
// Substitution for the same archetype as in a previous argument.
bool isNonSubstitutableArchetype = !nonSubstitutableArchetype.isNull() &&
nonSubstitutableArchetype->isEqual(archetype);
if (substitution->isEqual(existingSubstitution)) {
if (isNonSubstitutableArchetype) {
++nonSubstitutableArgs;
matched = false;
}
} else {
// If we have only one nonSubstitutableArg so far, then this different
// type might be the one that we should be substituting for instead.
// Note that failureInfo is already set correctly for that case.
if (isNonSubstitutableArchetype && nonSubstitutableArgs == 1 &&
isSubstitutableFor(substitution, archetype, CS.DC)) {
mismatchesAreNearMisses = argumentMismatchIsNearMiss(existingSubstitution, substitution);
allGenericSubstitutions[archetype] = substitution;
} else {
genericWithDifferingConcreteTypes = true;
matched = false;
}
}
}
}
}
if (matched)
continue;
// If the real argument is unresolved, the candidate isn't a mismatch because
// the type could be anything, but it's still useful to save the argument number as
// failureInfo.
if (rArgType->hasUnresolvedType() && !mismatchingArgs) {
failureInfo.argumentNumber = argNo;
} else {
if (archetypesMap.empty())
mismatchesAreNearMisses &= argumentMismatchIsNearMiss(argType, paramType);
++mismatchingArgs;
failureInfo.argumentNumber = argNo;
failureInfo.parameterType = paramType;
if (paramType->hasTypeParameter())
failureInfo.declContext = dc;
}
}
}
if (mismatchingArgs == 0)
return { CC_ExactMatch, failureInfo};
// Check to see if the first argument expects an inout argument, but is not
// an lvalue.
if (candArgs[0].isInOut() &&
!(actualArgs[0].getType()->hasLValueType() || actualArgs[0].isInOut())) {
return { CC_NonLValueInOut, {}};
}
// If we have exactly one argument mismatching, classify it specially, so that
// close matches are prioritized against obviously wrong ones.
if (mismatchingArgs == 1) {
CandidateCloseness closeness;
if (allGenericSubstitutions.empty()) {
closeness = mismatchesAreNearMisses ? CC_OneArgumentNearMismatch
: CC_OneArgumentMismatch;
} else {
// If the failure is that different occurrences of the same generic have
// different concrete types, substitute in all the concrete types we've found
// into the failureInfo to improve diagnosis.
if (genericWithDifferingConcreteTypes) {
auto newType = failureInfo.parameterType.transform([&](Type type) -> Type {
if (auto archetype = type->getAs<ArchetypeType>())
if (auto replacement = allGenericSubstitutions[archetype])
return replacement;
return type;
});
failureInfo.parameterType = newType;
}
closeness = mismatchesAreNearMisses ? CC_OneGenericArgumentNearMismatch
: CC_OneGenericArgumentMismatch;
}
// Return information about the single failing argument.
return { closeness, failureInfo };
}
if (nonSubstitutableArgs == mismatchingArgs)
return { CC_GenericNonsubstitutableMismatch, failureInfo };
auto closeness = mismatchesAreNearMisses ? CC_ArgumentNearMismatch
: CC_ArgumentMismatch;
return { closeness, {}};
}
