carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-28 22:02:37 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Parameterized impl declarations (#1189)

Browse Source 
* parameterized impls, first step

* bug fixes, comments, etc.

* added another test case, fix a bug in impl lookup

* simplify tests, removing tuple stuff

* don't create impl bindings for -bound implicit parameters

* remove a redundant 'private'

* CamelCase

* add missing backtick

* add a comment
This commit is contained in:
Jeremy G. Siek
2022-04-20 10:18:01 -04:00
committed by GitHub
parent 958fb8e529
commit b784458aef
20 changed files with 893 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/interpreter/impl_scope.cpp
+60 -38
View File
@@ -4,7 +4,7 @@
#include "executable_semantics/interpreter/impl_scope.h"
#include "executable_semantics/common/error_builders.h"
#include "executable_semantics/interpreter/type_checker.h"
#include "executable_semantics/interpreter/value.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Casting.h"
@@ -14,8 +14,20 @@ using llvm::cast;
namespace Carbon {
void ImplScope::Add(Nonnull<const Value*> iface, Nonnull<const Value*> type,
ValueNodeView impl) {
impls_.push_back({.interface = iface, .type = type, .impl = impl});
Nonnull<Expression*> impl) {
Add(iface, {}, type, {}, impl);
}
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,
.deduced = deduced,
.type = type,
.impl_bindings = impl_bindings,
.impl = impl});
}
void ImplScope::AddParent(Nonnull<const ImplScope*> parent) {
@@ -23,11 +35,12 @@ void ImplScope::AddParent(Nonnull<const ImplScope*> parent) {
}
auto ImplScope::Resolve(Nonnull<const Value*> iface_type,
Nonnull<const Value*> type,
SourceLocation source_loc) const
-> ErrorOr<ValueNodeView> {
ASSIGN_OR_RETURN(std::optional<ValueNodeView> result,
TryResolve(iface_type, type, source_loc));
Nonnull<const Value*> type, SourceLocation source_loc,
const TypeChecker& type_checker) const
-> ErrorOr<Nonnull<Expression*>> {
ASSIGN_OR_RETURN(
std::optional<Nonnull<Expression*>> result,
TryResolve(iface_type, type, source_loc, *this, type_checker));
if (!result.has_value()) {
return CompilationError(source_loc) << "could not find implementation of "
<< *iface_type << " for " << *type;
@@ -37,45 +50,54 @@ auto ImplScope::Resolve(Nonnull<const Value*> iface_type,
auto ImplScope::TryResolve(Nonnull<const Value*> iface_type,
Nonnull<const Value*> type,
SourceLocation source_loc) const
-> ErrorOr<std::optional<ValueNodeView>> {
std::optional<ValueNodeView> result =
ResolveHere(iface_type, type, source_loc);
if (result.has_value()) {
return result;
}
SourceLocation source_loc,
const ImplScope& original_scope,
const TypeChecker& type_checker) const
-> ErrorOr<std::optional<Nonnull<Expression*>>> {
ASSIGN_OR_RETURN(
std::optional<Nonnull<Expression*>> result,
ResolveHere(iface_type, type, source_loc, original_scope, type_checker));
for (Nonnull<const ImplScope*> parent : parent_scopes_) {
ASSIGN_OR_RETURN(auto parent_result,
parent->TryResolve(iface_type, type, source_loc));
if (parent_result.has_value() && result.has_value() &&
*parent_result != *result) {
return CompilationError(source_loc) << "ambiguous implementations of "
<< *iface_type << " for " << *type;
ASSIGN_OR_RETURN(std::optional<Nonnull<Expression*>> parent_result,
parent->TryResolve(iface_type, type, source_loc,
original_scope, type_checker));
if (parent_result.has_value()) {
if (result.has_value()) {
return CompilationError(source_loc) << "ambiguous implementations of "
<< *iface_type << " for " << *type;
} else {
result = *parent_result;
}
}
result = parent_result;
}
return result;
}
auto ImplScope::ResolveHere(Nonnull<const Value*> iface_type,
Nonnull<const Value*> impl_type,
SourceLocation /*source_loc*/) const
-> std::optional<ValueNodeView> {
switch (iface_type->kind()) {
case Value::Kind::InterfaceType: {
const auto& iface = cast<InterfaceType>(*iface_type);
for (const Impl& impl : impls_) {
if (TypeEqual(&iface, impl.interface) &&
TypeEqual(impl_type, impl.type)) {
return impl.impl;
}
}
return std::nullopt;
}
default:
FATAL() << "expected an interface, not " << *iface_type;
break;
SourceLocation source_loc,
const ImplScope& original_scope,
const TypeChecker& type_checker) const
-> ErrorOr<std::optional<Nonnull<Expression*>>> {
if (iface_type->kind() != Value::Kind::InterfaceType) {
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);
if (m.has_value()) {
if (result.has_value()) {
return CompilationError(source_loc)
<< "ambiguous implementations of " << *iface_type << " for "
<< *impl_type;
} else {
result = *m;
}
}
}
return result;
}
// TODO: Add indentation when printing the parents.