carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-05 21:51:12 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Initial support for constraints formed by combining interfaces (#1307)

Browse Source 
Add scaffolding for constraints in general, and support specifically constraints formed by applying a `&` operator.

No support for constraints formed with `where` nor for named constraints at this point.
This commit is contained in:
Richard Smith
2022-06-07 13:59:23 -07:00
committed by GitHub
parent 058b5e77c0
commit 1bb370420b
19 changed files with 822 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files
explorer/interpreter/impl_scope.cpp
+54 -14
View File
@@ -10,34 +10,78 @@
#include "llvm/Support/Casting.h"
using llvm::cast;
using llvm::dyn_cast;
namespace Carbon {
void ImplScope::Add(Nonnull<const Value*> iface, Nonnull<const Value*> type,
Nonnull<Expression*> impl) {
Add(iface, {}, type, {}, impl);
Nonnull<Expression*> impl,
const TypeChecker& type_checker) {
Add(iface, {}, type, {}, impl, type_checker);
}
void ImplScope::Add(Nonnull<const Value*> iface,
llvm::ArrayRef<Nonnull<const GenericBinding*>> deduced,
Nonnull<const Value*> type,
llvm::ArrayRef<Nonnull<const ImplBinding*>> impl_bindings,
Nonnull<Expression*> impl) {
impls_.push_back({.interface = iface,
Nonnull<Expression*> impl_expr,
const TypeChecker& type_checker) {
if (auto* constraint = dyn_cast<ConstraintType>(iface)) {
BindingMap map;
map[constraint->self_binding()] = type;
for (size_t i = 0; i != constraint->impl_constraints().size(); ++i) {
ConstraintType::ImplConstraint impl = constraint->impl_constraints()[i];
Add(cast<InterfaceType>(type_checker.Substitute(map, impl.interface)),
deduced, type_checker.Substitute(map, impl.type), impl_bindings,
type_checker.MakeConstraintWitnessAccess(impl_expr, i), type_checker);
}
return;
}
impls_.push_back({.interface = cast<InterfaceType>(iface),
.deduced = deduced,
.type = type,
.impl_bindings = impl_bindings,
.impl = impl});
.impl = impl_expr});
}
void ImplScope::AddParent(Nonnull<const ImplScope*> parent) {
parent_scopes_.push_back(parent);
}
auto ImplScope::Resolve(Nonnull<const Value*> iface_type,
Nonnull<const Value*> type, SourceLocation source_loc,
auto ImplScope::Resolve(Nonnull<const Value*> constraint_type,
Nonnull<const Value*> impl_type,
SourceLocation source_loc,
const TypeChecker& type_checker) const
-> ErrorOr<Nonnull<Expression*>> {
if (const auto* iface_type = dyn_cast<InterfaceType>(constraint_type)) {
return ResolveInterface(iface_type, impl_type, source_loc, type_checker);
}
if (const auto* constraint = dyn_cast<ConstraintType>(constraint_type)) {
std::vector<Nonnull<Expression*>> witnesses;
BindingMap map;
map[constraint->self_binding()] = impl_type;
for (auto impl : constraint->impl_constraints()) {
CARBON_ASSIGN_OR_RETURN(
Nonnull<Expression*> result,
ResolveInterface(
cast<InterfaceType>(type_checker.Substitute(map, impl.interface)),
type_checker.Substitute(map, impl.type), source_loc,
type_checker));
witnesses.push_back(result);
}
// TODO: Check satisfaction of same-type constraints.
return type_checker.MakeConstraintWitness(*constraint, std::move(witnesses),
source_loc);
}
CARBON_FATAL() << "expected a constraint, not " << *constraint_type;
}
auto ImplScope::ResolveInterface(Nonnull<const InterfaceType*> iface_type,
Nonnull<const Value*> type,
SourceLocation source_loc,
const TypeChecker& type_checker) const
-> ErrorOr<Nonnull<Expression*>> {
CARBON_ASSIGN_OR_RETURN(
std::optional<Nonnull<Expression*>> result,
TryResolve(iface_type, type, source_loc, *this, type_checker));
@@ -48,7 +92,7 @@ auto ImplScope::Resolve(Nonnull<const Value*> iface_type,
return *result;
}
auto ImplScope::TryResolve(Nonnull<const Value*> iface_type,
auto ImplScope::TryResolve(Nonnull<const InterfaceType*> iface_type,
Nonnull<const Value*> type,
SourceLocation source_loc,
const ImplScope& original_scope,
@@ -73,20 +117,16 @@ auto ImplScope::TryResolve(Nonnull<const Value*> iface_type,
return result;
}
auto ImplScope::ResolveHere(Nonnull<const Value*> iface_type,
auto ImplScope::ResolveHere(Nonnull<const InterfaceType*> iface_type,
Nonnull<const Value*> impl_type,
SourceLocation source_loc,
const ImplScope& original_scope,
const TypeChecker& type_checker) const
-> ErrorOr<std::optional<Nonnull<Expression*>>> {
if (iface_type->kind() != Value::Kind::InterfaceType) {
CARBON_FATAL() << "expected an interface, not " << *iface_type;
}
const auto& iface = cast<InterfaceType>(*iface_type);
std::optional<Nonnull<Expression*>> result = std::nullopt;
for (const Impl& impl : impls_) {
std::optional<Nonnull<Expression*>> m = type_checker.MatchImpl(
iface, impl_type, impl, original_scope, source_loc);
*iface_type, impl_type, impl, original_scope, source_loc);
if (m.has_value()) {
if (result.has_value()) {
return CompilationError(source_loc)