|
|
@@ -503,11 +503,11 @@ auto TypeChecker::BuildBuiltinMethodCall(const ImplScope& impl_scope,
|
|
|
Nonnull<Expression*> iface_expr = arena_->New<ValueLiteral>(
|
|
|
source_loc, iface_type, arena_->New<TypeOfInterfaceType>(iface_type),
|
|
|
ValueCategory::Let);
|
|
|
- Nonnull<Expression*> iface_member =
|
|
|
- arena_->New<FieldAccessExpression>(source_loc, iface_expr, method.name);
|
|
|
+ Nonnull<Expression*> iface_member = arena_->New<SimpleMemberAccessExpression>(
|
|
|
+ source_loc, iface_expr, method.name);
|
|
|
Nonnull<Expression*> method_access =
|
|
|
- arena_->New<CompoundFieldAccessExpression>(source_loc, source,
|
|
|
- iface_member);
|
|
|
+ arena_->New<CompoundMemberAccessExpression>(source_loc, source,
|
|
|
+ iface_member);
|
|
|
Nonnull<Expression*> call_args =
|
|
|
arena_->New<TupleLiteral>(source_loc, method.arguments);
|
|
|
Nonnull<Expression*> call =
|
|
|
@@ -1051,12 +1051,12 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
<< " generated during type checking";
|
|
|
case ExpressionKind::IndexExpression: {
|
|
|
auto& index = cast<IndexExpression>(*e);
|
|
|
- CARBON_RETURN_IF_ERROR(TypeCheckExp(&index.aggregate(), impl_scope));
|
|
|
+ CARBON_RETURN_IF_ERROR(TypeCheckExp(&index.object(), impl_scope));
|
|
|
CARBON_RETURN_IF_ERROR(TypeCheckExp(&index.offset(), impl_scope));
|
|
|
- const Value& aggregate_type = index.aggregate().static_type();
|
|
|
- switch (aggregate_type.kind()) {
|
|
|
+ const Value& object_type = index.object().static_type();
|
|
|
+ switch (object_type.kind()) {
|
|
|
case Value::Kind::TupleValue: {
|
|
|
- const auto& tuple_type = cast<TupleValue>(aggregate_type);
|
|
|
+ const auto& tuple_type = cast<TupleValue>(object_type);
|
|
|
CARBON_RETURN_IF_ERROR(ExpectExactType(
|
|
|
index.offset().source_loc(), "tuple index",
|
|
|
arena_->New<IntType>(), &index.offset().static_type()));
|
|
|
@@ -1070,7 +1070,7 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
<< tuple_type;
|
|
|
}
|
|
|
index.set_static_type(tuple_type.elements()[i]);
|
|
|
- index.set_value_category(index.aggregate().value_category());
|
|
|
+ index.set_value_category(index.object().value_category());
|
|
|
return Success();
|
|
|
}
|
|
|
case Value::Kind::StaticArrayType: {
|
|
|
@@ -1078,8 +1078,8 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
index.offset().source_loc(), "array index",
|
|
|
arena_->New<IntType>(), &index.offset().static_type()));
|
|
|
index.set_static_type(
|
|
|
- &cast<StaticArrayType>(aggregate_type).element_type());
|
|
|
- index.set_value_category(index.aggregate().value_category());
|
|
|
+ &cast<StaticArrayType>(object_type).element_type());
|
|
|
+ index.set_value_category(index.object().value_category());
|
|
|
return Success();
|
|
|
}
|
|
|
default:
|
|
|
@@ -1127,31 +1127,31 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
e->set_value_category(ValueCategory::Let);
|
|
|
return Success();
|
|
|
}
|
|
|
- case ExpressionKind::FieldAccessExpression: {
|
|
|
- auto& access = cast<FieldAccessExpression>(*e);
|
|
|
- CARBON_RETURN_IF_ERROR(TypeCheckExp(&access.aggregate(), impl_scope));
|
|
|
- const Value& aggregate_type = access.aggregate().static_type();
|
|
|
- switch (aggregate_type.kind()) {
|
|
|
+ case ExpressionKind::SimpleMemberAccessExpression: {
|
|
|
+ auto& access = cast<SimpleMemberAccessExpression>(*e);
|
|
|
+ CARBON_RETURN_IF_ERROR(TypeCheckExp(&access.object(), impl_scope));
|
|
|
+ const Value& object_type = access.object().static_type();
|
|
|
+ switch (object_type.kind()) {
|
|
|
case Value::Kind::StructType: {
|
|
|
- const auto& struct_type = cast<StructType>(aggregate_type);
|
|
|
+ const auto& struct_type = cast<StructType>(object_type);
|
|
|
for (const auto& [field_name, field_type] : struct_type.fields()) {
|
|
|
- if (access.field() == field_name) {
|
|
|
+ if (access.member() == field_name) {
|
|
|
access.set_static_type(field_type);
|
|
|
- access.set_value_category(access.aggregate().value_category());
|
|
|
+ access.set_value_category(access.object().value_category());
|
|
|
return Success();
|
|
|
}
|
|
|
}
|
|
|
return CompilationError(access.source_loc())
|
|
|
<< "struct " << struct_type << " does not have a field named "
|
|
|
- << access.field();
|
|
|
+ << access.member();
|
|
|
}
|
|
|
case Value::Kind::TypeType: {
|
|
|
CARBON_ASSIGN_OR_RETURN(
|
|
|
Nonnull<const Value*> type,
|
|
|
- InterpExp(&access.aggregate(), arena_, trace_stream_));
|
|
|
+ InterpExp(&access.object(), arena_, trace_stream_));
|
|
|
if (const auto* struct_type = dyn_cast<StructType>(type)) {
|
|
|
for (const auto& field : struct_type->fields()) {
|
|
|
- if (access.field() == field.name) {
|
|
|
+ if (access.member() == field.name) {
|
|
|
access.set_static_type(
|
|
|
arena_->New<TypeOfMemberName>(Member(&field)));
|
|
|
access.set_value_category(ValueCategory::Let);
|
|
|
@@ -1160,7 +1160,7 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
}
|
|
|
return CompilationError(access.source_loc())
|
|
|
<< "struct " << *struct_type
|
|
|
- << " does not have a field named " << access.field();
|
|
|
+ << " does not have a field named " << access.member();
|
|
|
}
|
|
|
// TODO: We should handle all types here, not only structs. For
|
|
|
// example:
|
|
|
@@ -1175,22 +1175,22 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
<< "unsupported member access into type " << *type;
|
|
|
}
|
|
|
case Value::Kind::NominalClassType: {
|
|
|
- const auto& t_class = cast<NominalClassType>(aggregate_type);
|
|
|
+ const auto& t_class = cast<NominalClassType>(object_type);
|
|
|
if (std::optional<Nonnull<const Declaration*>> member =
|
|
|
- FindMember(access.field(), t_class.declaration().members());
|
|
|
+ FindMember(access.member(), t_class.declaration().members());
|
|
|
member.has_value()) {
|
|
|
Nonnull<const Value*> field_type =
|
|
|
Substitute(t_class.type_args(), &(*member)->static_type());
|
|
|
access.set_static_type(field_type);
|
|
|
switch ((*member)->kind()) {
|
|
|
case DeclarationKind::VariableDeclaration:
|
|
|
- access.set_value_category(access.aggregate().value_category());
|
|
|
+ access.set_value_category(access.object().value_category());
|
|
|
break;
|
|
|
case DeclarationKind::FunctionDeclaration:
|
|
|
access.set_value_category(ValueCategory::Let);
|
|
|
break;
|
|
|
default:
|
|
|
- CARBON_FATAL() << "member " << access.field()
|
|
|
+ CARBON_FATAL() << "member " << access.member()
|
|
|
<< " is not a field or method";
|
|
|
break;
|
|
|
}
|
|
|
@@ -1198,18 +1198,18 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
} else {
|
|
|
return CompilationError(e->source_loc())
|
|
|
<< "class " << t_class.declaration().name()
|
|
|
- << " does not have a field named " << access.field();
|
|
|
+ << " does not have a field named " << access.member();
|
|
|
}
|
|
|
}
|
|
|
case Value::Kind::TypeOfChoiceType: {
|
|
|
const ChoiceType& choice =
|
|
|
- cast<TypeOfChoiceType>(aggregate_type).choice_type();
|
|
|
+ cast<TypeOfChoiceType>(object_type).choice_type();
|
|
|
std::optional<Nonnull<const Value*>> parameter_types =
|
|
|
- choice.FindAlternative(access.field());
|
|
|
+ choice.FindAlternative(access.member());
|
|
|
if (!parameter_types.has_value()) {
|
|
|
return CompilationError(e->source_loc())
|
|
|
<< "choice " << choice.name()
|
|
|
- << " does not have a field named " << access.field();
|
|
|
+ << " does not have an alternative named " << access.member();
|
|
|
}
|
|
|
access.set_static_type(arena_->New<FunctionType>(
|
|
|
*parameter_types, llvm::None, &choice, llvm::None, llvm::None));
|
|
|
@@ -1218,9 +1218,9 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
}
|
|
|
case Value::Kind::TypeOfClassType: {
|
|
|
const NominalClassType& class_type =
|
|
|
- cast<TypeOfClassType>(aggregate_type).class_type();
|
|
|
+ cast<TypeOfClassType>(object_type).class_type();
|
|
|
if (std::optional<Nonnull<const Declaration*>> member = FindMember(
|
|
|
- access.field(), class_type.declaration().members());
|
|
|
+ access.member(), class_type.declaration().members());
|
|
|
member.has_value()) {
|
|
|
switch ((*member)->kind()) {
|
|
|
case DeclarationKind::FunctionDeclaration: {
|
|
|
@@ -1244,14 +1244,14 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
} else {
|
|
|
return CompilationError(access.source_loc())
|
|
|
<< class_type << " does not have a member named "
|
|
|
- << access.field();
|
|
|
+ << access.member();
|
|
|
}
|
|
|
}
|
|
|
case Value::Kind::TypeOfInterfaceType: {
|
|
|
const InterfaceType& iface_type =
|
|
|
- cast<TypeOfInterfaceType>(aggregate_type).interface_type();
|
|
|
+ cast<TypeOfInterfaceType>(object_type).interface_type();
|
|
|
if (std::optional<Nonnull<const Declaration*>> member = FindMember(
|
|
|
- access.field(), iface_type.declaration().members());
|
|
|
+ access.member(), iface_type.declaration().members());
|
|
|
member.has_value()) {
|
|
|
access.set_static_type(
|
|
|
arena_->New<TypeOfMemberName>(Member(*member)));
|
|
|
@@ -1260,7 +1260,7 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
} else {
|
|
|
return CompilationError(access.source_loc())
|
|
|
<< iface_type << " does not have a member named "
|
|
|
- << access.field();
|
|
|
+ << access.member();
|
|
|
}
|
|
|
}
|
|
|
case Value::Kind::VariableType: {
|
|
|
@@ -1268,14 +1268,14 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
// is a type variable. For example, `x.foo` where the type of
|
|
|
// `x` is `T` and `foo` and `T` implements an interface that
|
|
|
// includes `foo`.
|
|
|
- const VariableType& var_type = cast<VariableType>(aggregate_type);
|
|
|
+ const VariableType& var_type = cast<VariableType>(object_type);
|
|
|
const Value& typeof_var = var_type.binding().static_type();
|
|
|
switch (typeof_var.kind()) {
|
|
|
case Value::Kind::InterfaceType: {
|
|
|
const auto& iface_type = cast<InterfaceType>(typeof_var);
|
|
|
const InterfaceDeclaration& iface_decl = iface_type.declaration();
|
|
|
if (std::optional<Nonnull<const Declaration*>> member =
|
|
|
- FindMember(access.field(), iface_decl.members());
|
|
|
+ FindMember(access.member(), iface_decl.members());
|
|
|
member.has_value()) {
|
|
|
const Value& member_type = (*member)->static_type();
|
|
|
BindingMap binding_map = iface_type.args();
|
|
|
@@ -1288,14 +1288,14 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
return Success();
|
|
|
} else {
|
|
|
return CompilationError(e->source_loc())
|
|
|
- << "field access, " << access.field() << " not in "
|
|
|
+ << "member access, " << access.member() << " not in "
|
|
|
<< iface_decl.name();
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
default:
|
|
|
return CompilationError(e->source_loc())
|
|
|
- << "field access, unexpected " << aggregate_type
|
|
|
+ << "member access, unexpected " << object_type
|
|
|
<< " of non-interface type " << typeof_var << " in " << *e;
|
|
|
}
|
|
|
break;
|
|
|
@@ -1307,12 +1307,12 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
// function of `T`.
|
|
|
CARBON_ASSIGN_OR_RETURN(
|
|
|
Nonnull<const Value*> var_addr,
|
|
|
- InterpExp(&access.aggregate(), arena_, trace_stream_));
|
|
|
+ InterpExp(&access.object(), arena_, trace_stream_));
|
|
|
const VariableType& var_type = cast<VariableType>(*var_addr);
|
|
|
- const InterfaceType& iface_type = cast<InterfaceType>(aggregate_type);
|
|
|
+ const InterfaceType& iface_type = cast<InterfaceType>(object_type);
|
|
|
const InterfaceDeclaration& iface_decl = iface_type.declaration();
|
|
|
if (std::optional<Nonnull<const Declaration*>> member =
|
|
|
- FindMember(access.field(), iface_decl.members());
|
|
|
+ FindMember(access.member(), iface_decl.members());
|
|
|
member.has_value()) {
|
|
|
CARBON_CHECK(var_type.binding().impl_binding().has_value());
|
|
|
access.set_impl(*var_type.binding().impl_binding());
|
|
|
@@ -1344,19 +1344,18 @@ auto TypeChecker::TypeCheckExp(Nonnull<Expression*> e,
|
|
|
return Success();
|
|
|
} else {
|
|
|
return CompilationError(e->source_loc())
|
|
|
- << "field access, " << access.field() << " not in "
|
|
|
+ << "member access, " << access.member() << " not in "
|
|
|
<< iface_decl.name();
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
default:
|
|
|
return CompilationError(e->source_loc())
|
|
|
- << "field access, unexpected " << aggregate_type << " in "
|
|
|
- << *e;
|
|
|
+ << "member access, unexpected " << object_type << " in " << *e;
|
|
|
}
|
|
|
}
|
|
|
- case ExpressionKind::CompoundFieldAccessExpression: {
|
|
|
- auto& access = cast<CompoundFieldAccessExpression>(*e);
|
|
|
+ case ExpressionKind::CompoundMemberAccessExpression: {
|
|
|
+ auto& access = cast<CompoundMemberAccessExpression>(*e);
|
|
|
CARBON_RETURN_IF_ERROR(TypeCheckExp(&access.object(), impl_scope));
|
|
|
CARBON_RETURN_IF_ERROR(TypeCheckExp(&access.path(), impl_scope));
|
|
|
if (!isa<TypeOfMemberName>(access.path().static_type())) {
|