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

Drop CopyVal (#895)

Browse Source 
Values are immutable, so they should never need to be copied.
This commit is contained in:
Geoff Romer
2021-10-18 15:58:35 -07:00
committed by GitHub
parent 7670f08200
commit c4d7adde9a
3 changed files with 5 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/interpreter/value.cpp
-84
View File
@@ -291,90 +291,6 @@ void Value::Print(llvm::raw_ostream& out) const {
}
}
auto CopyVal(Nonnull<Arena*> arena, Nonnull<const Value*> val,
SourceLocation source_loc) -> Nonnull<const Value*> {
switch (val->kind()) {
case Value::Kind::TupleValue: {
std::vector<Nonnull<const Value*>> elements;
for (Nonnull<const Value*> element : cast<TupleValue>(*val).elements()) {
elements.push_back(CopyVal(arena, element, source_loc));
}
return arena->New<TupleValue>(std::move(elements));
}
case Value::Kind::AlternativeValue: {
const auto& alt = cast<AlternativeValue>(*val);
Nonnull<const Value*> arg = CopyVal(arena, &alt.argument(), source_loc);
return arena->New<AlternativeValue>(alt.alt_name(), alt.choice_name(),
arg);
}
case Value::Kind::StructValue: {
std::vector<StructElement> elements;
for (const StructElement& element : cast<StructValue>(*val).elements()) {
elements.push_back(
{.name = element.name,
.value = CopyVal(arena, element.value, source_loc)});
}
return arena->New<StructValue>(std::move(elements));
}
case Value::Kind::NominalClassValue: {
const auto& s = cast<NominalClassValue>(*val);
Nonnull<const Value*> inits = CopyVal(arena, &s.inits(), source_loc);
return arena->New<NominalClassValue>(&s.type(), inits);
}
case Value::Kind::IntValue:
return arena->New<IntValue>(cast<IntValue>(*val).value());
case Value::Kind::BoolValue:
return arena->New<BoolValue>(cast<BoolValue>(*val).value());
case Value::Kind::FunctionValue: {
const auto& fn_value = cast<FunctionValue>(*val);
return arena->New<FunctionValue>(fn_value.name(), &fn_value.parameters(),
fn_value.body());
}
case Value::Kind::PointerValue:
return arena->New<PointerValue>(cast<PointerValue>(*val).value());
case Value::Kind::ContinuationValue:
return arena->New<ContinuationValue>(
&cast<ContinuationValue>(*val).stack());
case Value::Kind::FunctionType: {
const auto& fn_type = cast<FunctionType>(*val);
return arena->New<FunctionType>(
fn_type.deduced(), CopyVal(arena, &fn_type.parameters(), source_loc),
CopyVal(arena, &fn_type.return_type(), source_loc));
}
case Value::Kind::PointerType:
return arena->New<PointerType>(
CopyVal(arena, &cast<PointerType>(*val).type(), source_loc));
case Value::Kind::IntType:
return arena->New<IntType>();
case Value::Kind::BoolType:
return arena->New<BoolType>();
case Value::Kind::TypeType:
return arena->New<TypeType>();
case Value::Kind::AutoType:
return arena->New<AutoType>();
case Value::Kind::ContinuationType:
return arena->New<ContinuationType>();
case Value::Kind::StringType:
return arena->New<StringType>();
case Value::Kind::StringValue:
return arena->New<StringValue>(cast<StringValue>(*val).value());
case Value::Kind::StructType: {
VarValues fields;
for (const auto& [name, type] : cast<StructType>(*val).fields()) {
fields.push_back({name, CopyVal(arena, type, source_loc)});
}
return arena->New<StructType>(fields);
}
case Value::Kind::VariableType:
case Value::Kind::NominalClassType:
case Value::Kind::ChoiceType:
case Value::Kind::BindingPlaceholderValue:
case Value::Kind::AlternativeConstructorValue:
// TODO: These should be copied so that they don't get destructed.
return val;
}
}
auto TypeEqual(Nonnull<const Value*> t1, Nonnull<const Value*> t2) -> bool {
if (t1->kind() != t2->kind()) {
return false;