mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
5a8d0744c3
Structurally prevent a number of common anti-patterns involving generic signatures by separating the interface into GenericSignature and the implementation into GenericSignatureBase. In particular, this allows the comparison operators to be deleted which forces callers to canonicalize the signature or ask to compare pointers explicitly.
125 lines
4.5 KiB
C++
125 lines
4.5 KiB
C++
//===--- RequirementEnvironment.h - Requirement Environments ----*- C++ -*-===//
|
|
//
|
|
// 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 defines the RequirementEnvironment class, which is used to
|
|
// capture how a witness to a protocol requirement maps type parameters.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_AST_REQUIREMENT_ENVIRONMENT_H
|
|
#define SWIFT_AST_REQUIREMENT_ENVIRONMENT_H
|
|
|
|
#include "swift/AST/SubstitutionMap.h"
|
|
|
|
namespace swift {
|
|
|
|
/// Describes the environment of a requirement that will be used when
|
|
/// matching witnesses against the requirement and to form the resulting
|
|
/// \c Witness value.
|
|
///
|
|
/// The produced generic environment will have a fresh set of archetypes that
|
|
/// describe the combined constraints of the requirement (because those
|
|
/// are available to all potential witnesses) as well as the constraints from
|
|
/// the context to which the protocol conformance is ascribed, which may
|
|
/// include additional constraints beyond those of the extended type if the
|
|
/// conformance is conditional. The type parameters for the generic
|
|
/// environment are the type parameters of the conformance context
|
|
/// (\c conformanceDC) with another (deeper) level of type parameters for
|
|
/// generic requirements. See the \c Witness class for more information about
|
|
/// this synthetic environment.
|
|
class RequirementEnvironment {
|
|
/// A generic signature that combines the generic parameters of the
|
|
/// concrete conforming type with the generic parameters of the
|
|
/// requirement.
|
|
///
|
|
///
|
|
/// For example, if you have:
|
|
///
|
|
/// protocol P { func f<T>(_: T) }
|
|
/// struct S<A, B> : P { func f<T>(_: T) }
|
|
///
|
|
/// The requirement and witness signatures are, respectively:
|
|
///
|
|
/// <Self : P, T>
|
|
/// <A, B, T>
|
|
///
|
|
/// The synthetic signature in this case is just the witness signature.
|
|
///
|
|
/// It may be that the witness is more generic than the requirement,
|
|
/// for example:
|
|
///
|
|
/// protocol P { func f(_: Int) }
|
|
/// struct S<A, B> : P { func f<T>(_: T) { } }
|
|
///
|
|
/// Here, the requirement signature and witness signatures are:
|
|
///
|
|
/// <Self : P>
|
|
/// <A, B, T>
|
|
///
|
|
/// The synthetic signature is just:
|
|
///
|
|
/// <A, B>
|
|
///
|
|
/// The witness thunk emitted by SILGen uses the synthetic signature.
|
|
/// Therefore one invariant we preserve is that the witness thunk is
|
|
/// ABI compatible with the requirement's function type.
|
|
GenericSignature syntheticSignature = GenericSignature();
|
|
GenericEnvironment *syntheticEnvironment = nullptr;
|
|
|
|
/// The generic signature of the protocol requirement member.
|
|
GenericSignature reqSig = GenericSignature();
|
|
|
|
/// A substitution map mapping the requirement signature to the
|
|
/// generic parameters of the synthetic signature.
|
|
SubstitutionMap reqToSyntheticEnvMap;
|
|
|
|
public:
|
|
/// Create a new environment for matching the given requirement within a
|
|
/// particular conformance.
|
|
///
|
|
/// \param conformanceDC The \c DeclContext to which the protocol
|
|
/// conformance is ascribed, which provides additional constraints.
|
|
///
|
|
/// \param reqSig The generic signature of the requirement for which we
|
|
/// are creating a generic environment.
|
|
///
|
|
/// \param proto The protocol containing the requirement.
|
|
///
|
|
/// \param conformance The protocol conformance, or null if there is no
|
|
/// conformance (because we're finding default implementations).
|
|
RequirementEnvironment(DeclContext *conformanceDC,
|
|
GenericSignature reqSig,
|
|
ProtocolDecl *proto,
|
|
ClassDecl *covariantSelf,
|
|
ProtocolConformance *conformance);
|
|
|
|
/// Retrieve the synthetic generic environment.
|
|
GenericEnvironment *getSyntheticEnvironment() const {
|
|
return syntheticEnvironment;
|
|
}
|
|
|
|
/// Retrieve the generic signature of the requirement.
|
|
GenericSignature getRequirementSignature() const {
|
|
return reqSig;
|
|
}
|
|
|
|
/// Retrieve the substitution map that maps the interface types of the
|
|
/// requirement to the interface types of the synthetic environment.
|
|
SubstitutionMap getRequirementToSyntheticMap() const {
|
|
return reqToSyntheticEnvMap;
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif // SWIFT_AST_REQUIREMENT_ENVIRONMENT_H
|