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

Consistent naming for Expression and Value. (#621)

Browse Source 
- `Kind` enumerator names always match the corresponding factory function, accessor, and type names (if any).
- All abbreviations in those names are expanded.
- Those names always have a suffix to disambiguate expressions from values.

`VarTV` is excluded from these changes because there's a pending PR to remove it.
This commit is contained in:
Geoff Romer
2021-07-07 11:32:33 -07:00
committed by GitHub
parent 7218e8a69e
commit a80ce2c566
9 changed files with 846 additions and 786 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/expression.cpp
+98 -84
View File
@@ -8,145 +8,158 @@
namespace Carbon {
auto Expression::GetVariable() const -> const Variable& {
return std::get<Variable>(value);
auto Expression::GetIdentifierExpression() const
-> const IdentifierExpression& {
return std::get<IdentifierExpression>(value);
}
auto Expression::GetFieldAccess() const -> const FieldAccess& {
return std::get<FieldAccess>(value);
auto Expression::GetFieldAccessExpression() const
-> const FieldAccessExpression& {
return std::get<FieldAccessExpression>(value);
}
auto Expression::GetIndex() const -> const Index& {
return std::get<Index>(value);
auto Expression::GetIndexExpression() const -> const IndexExpression& {
return std::get<IndexExpression>(value);
}
auto Expression::GetPatternVariable() const -> const PatternVariable& {
return std::get<PatternVariable>(value);
auto Expression::GetPatternVariableExpression() const
-> const PatternVariableExpression& {
return std::get<PatternVariableExpression>(value);
}
auto Expression::GetInteger() const -> int {
auto Expression::GetIntLiteral() const -> int {
return std::get<IntLiteral>(value).value;
}
auto Expression::GetBoolean() const -> bool {
auto Expression::GetBoolLiteral() const -> bool {
return std::get<BoolLiteral>(value).value;
}
auto Expression::GetTuple() const -> const Tuple& {
return std::get<Tuple>(value);
auto Expression::GetTupleLiteral() const -> const TupleLiteral& {
return std::get<TupleLiteral>(value);
}
auto Expression::GetPrimitiveOperator() const -> const PrimitiveOperator& {
return std::get<PrimitiveOperator>(value);
auto Expression::GetPrimitiveOperatorExpression() const
-> const PrimitiveOperatorExpression& {
return std::get<PrimitiveOperatorExpression>(value);
}
auto Expression::GetCall() const -> const Call& {
return std::get<Call>(value);
auto Expression::GetCallExpression() const -> const CallExpression& {
return std::get<CallExpression>(value);
}
auto Expression::GetFunctionType() const -> const FunctionType& {
return std::get<FunctionType>(value);
auto Expression::GetFunctionTypeLiteral() const -> const FunctionTypeLiteral& {
return std::get<FunctionTypeLiteral>(value);
}
auto Expression::MakeTypeType(int line_num) -> const Expression* {
auto Expression::MakeTypeTypeLiteral(int line_num) -> const Expression* {
auto* t = new Expression();
t->line_num = line_num;
t->value = TypeT();
t->value = TypeTypeLiteral();
return t;
}
auto Expression::MakeIntType(int line_num) -> const Expression* {
auto Expression::MakeIntTypeLiteral(int line_num) -> const Expression* {
auto* t = new Expression();
t->line_num = line_num;
t->value = IntT();
t->value = IntTypeLiteral();
return t;
}
auto Expression::MakeBoolType(int line_num) -> const Expression* {
auto Expression::MakeBoolTypeLiteral(int line_num) -> const Expression* {
auto* t = new Expression();
t->line_num = line_num;
t->value = BoolT();
t->value = BoolTypeLiteral();
return t;
}
auto Expression::MakeAutoType(int line_num) -> const Expression* {
auto Expression::MakeAutoTypeLiteral(int line_num) -> const Expression* {
auto* t = new Expression();
t->line_num = line_num;
t->value = AutoT();
t->value = AutoTypeLiteral();
return t;
}
// Returns a Continuation type AST node at the given source location.
auto Expression::MakeContinuationType(int line_num) -> const Expression* {
auto Expression::MakeContinuationTypeLiteral(int line_num)
-> const Expression* {
auto* type = new Expression();
type->line_num = line_num;
type->value = ContinuationT();
type->value = ContinuationTypeLiteral();
return type;
}
auto Expression::MakeFunType(int line_num, const Expression* param,
const Expression* ret) -> const Expression* {
auto Expression::MakeFunctionTypeLiteral(int line_num, const Expression* param,
const Expression* ret)
-> const Expression* {
auto* t = new Expression();
t->line_num = line_num;
t->value = FunctionType({.parameter = param, .return_type = ret});
t->value = FunctionTypeLiteral({.parameter = param, .return_type = ret});
return t;
}
auto Expression::MakeVar(int line_num, std::string var) -> const Expression* {
auto Expression::MakeIdentifierExpression(int line_num, std::string var)
-> const Expression* {
auto* v = new Expression();
v->line_num = line_num;
v->value = Variable({.name = std::move(var)});
v->value = IdentifierExpression({.name = std::move(var)});
return v;
}
auto Expression::MakeVarPat(int line_num, std::string var,
const Expression* type) -> const Expression* {
auto Expression::MakePatternVariableExpression(int line_num, std::string var,
const Expression* type)
-> const Expression* {
auto* v = new Expression();
v->line_num = line_num;
v->value = PatternVariable({.name = std::move(var), .type = type});
v->value = PatternVariableExpression({.name = std::move(var), .type = type});
return v;
}
auto Expression::MakeInt(int line_num, int i) -> const Expression* {
auto Expression::MakeIntLiteral(int line_num, int i) -> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = IntLiteral({.value = i});
return e;
}
auto Expression::MakeBool(int line_num, bool b) -> const Expression* {
auto Expression::MakeBoolLiteral(int line_num, bool b) -> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = BoolLiteral({.value = b});
return e;
}
auto Expression::MakeOp(int line_num, enum Operator op,
std::vector<const Expression*> args)
auto Expression::MakePrimitiveOperatorExpression(
int line_num, enum Operator op, std::vector<const Expression*> args)
-> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = PrimitiveOperator({.op = op, .arguments = std::move(args)});
e->value =
PrimitiveOperatorExpression({.op = op, .arguments = std::move(args)});
return e;
}
auto Expression::MakeCall(int line_num, const Expression* fun,
const Expression* arg) -> const Expression* {
auto Expression::MakeCallExpression(int line_num, const Expression* fun,
const Expression* arg)
-> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = Call({.function = fun, .argument = arg});
e->value = CallExpression({.function = fun, .argument = arg});
return e;
}
auto Expression::MakeGetField(int line_num, const Expression* exp,
std::string field) -> const Expression* {
auto Expression::MakeFieldAccessExpression(int line_num, const Expression* exp,
std::string field)
-> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = FieldAccess({.aggregate = exp, .field = std::move(field)});
e->value =
FieldAccessExpression({.aggregate = exp, .field = std::move(field)});
return e;
}
auto Expression::MakeTuple(int line_num, std::vector<FieldInitializer> args)
auto Expression::MakeTupleLiteral(int line_num,
std::vector<FieldInitializer> args)
-> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
@@ -166,15 +179,15 @@ auto Expression::MakeTuple(int line_num, std::vector<FieldInitializer> args)
seen_named_member = true;
}
}
e->value = Tuple({.fields = args});
e->value = TupleLiteral({.fields = args});
return e;
}
auto Expression::MakeIndex(int line_num, const Expression* exp,
const Expression* i) -> const Expression* {
auto Expression::MakeIndexExpression(int line_num, const Expression* exp,
const Expression* i) -> const Expression* {
auto* e = new Expression();
e->line_num = line_num;
e->value = Index({.aggregate = exp, .offset = i});
e->value = IndexExpression({.aggregate = exp, .offset = i});
return e;
}
@@ -220,32 +233,32 @@ static void PrintFields(const std::vector<FieldInitializer>& fields) {
void PrintExp(const Expression* e) {
switch (e->tag()) {
case ExpressionKind::Index:
PrintExp(e->GetIndex().aggregate);
case ExpressionKind::IndexExpression:
PrintExp(e->GetIndexExpression().aggregate);
std::cout << "[";
PrintExp(e->GetIndex().offset);
PrintExp(e->GetIndexExpression().offset);
std::cout << "]";
break;
case ExpressionKind::GetField:
PrintExp(e->GetFieldAccess().aggregate);
case ExpressionKind::FieldAccessExpression:
PrintExp(e->GetFieldAccessExpression().aggregate);
std::cout << ".";
std::cout << e->GetFieldAccess().field;
std::cout << e->GetFieldAccessExpression().field;
break;
case ExpressionKind::Tuple:
case ExpressionKind::TupleLiteral:
std::cout << "(";
PrintFields(e->GetTuple().fields);
PrintFields(e->GetTupleLiteral().fields);
std::cout << ")";
break;
case ExpressionKind::Integer:
std::cout << e->GetInteger();
case ExpressionKind::IntLiteral:
std::cout << e->GetIntLiteral();
break;
case ExpressionKind::Boolean:
case ExpressionKind::BoolLiteral:
std::cout << std::boolalpha;
std::cout << e->GetBoolean();
std::cout << e->GetBoolLiteral();
break;
case ExpressionKind::PrimitiveOp: {
case ExpressionKind::PrimitiveOperatorExpression: {
std::cout << "(";
PrimitiveOperator op = e->GetPrimitiveOperator();
PrimitiveOperatorExpression op = e->GetPrimitiveOperatorExpression();
if (op.arguments.size() == 0) {
PrintOp(op.op);
} else if (op.arguments.size() == 1) {
@@ -265,44 +278,45 @@ void PrintExp(const Expression* e) {
std::cout << ")";
break;
}
case ExpressionKind::Variable:
std::cout << e->GetVariable().name;
case ExpressionKind::IdentifierExpression:
std::cout << e->GetIdentifierExpression().name;
break;
case ExpressionKind::PatternVariable:
PrintExp(e->GetPatternVariable().type);
case ExpressionKind::PatternVariableExpression:
PrintExp(e->GetPatternVariableExpression().type);
std::cout << ": ";
std::cout << e->GetPatternVariable().name;
std::cout << e->GetPatternVariableExpression().name;
break;
case ExpressionKind::Call:
PrintExp(e->GetCall().function);
if (e->GetCall().argument->tag() == ExpressionKind::Tuple) {
PrintExp(e->GetCall().argument);
case ExpressionKind::CallExpression:
PrintExp(e->GetCallExpression().function);
if (e->GetCallExpression().argument->tag() ==
ExpressionKind::TupleLiteral) {
PrintExp(e->GetCallExpression().argument);
} else {
std::cout << "(";
PrintExp(e->GetCall().argument);
PrintExp(e->GetCallExpression().argument);
std::cout << ")";
}
break;
case ExpressionKind::BoolT:
case ExpressionKind::BoolTypeLiteral:
std::cout << "Bool";
break;
case ExpressionKind::IntT:
case ExpressionKind::IntTypeLiteral:
std::cout << "Int";
break;
case ExpressionKind::TypeT:
case ExpressionKind::TypeTypeLiteral:
std::cout << "Type";
break;
case ExpressionKind::AutoT:
case ExpressionKind::AutoTypeLiteral:
std::cout << "auto";
break;
case ExpressionKind::ContinuationT:
case ExpressionKind::ContinuationTypeLiteral:
std::cout << "Continuation";
break;
case ExpressionKind::FunctionT:
case ExpressionKind::FunctionTypeLiteral:
std::cout << "fn ";
PrintExp(e->GetFunctionType().parameter);
PrintExp(e->GetFunctionTypeLiteral().parameter);
std::cout << " -> ";
PrintExp(e->GetFunctionType().return_type);
PrintExp(e->GetFunctionTypeLiteral().return_type);
break;
}
}
executable_semantics/ast/expression.h
+86 -76
View File
@@ -23,21 +23,21 @@ struct FieldInitializer {
};
enum class ExpressionKind {
AutoT,
BoolT,
Boolean,
Call,
FunctionT,
GetField,
Index,
IntT,
ContinuationT, // The type of a continuation value.
Integer,
PatternVariable,
PrimitiveOp,
Tuple,
TypeT,
Variable,
AutoTypeLiteral,
BoolTypeLiteral,
BoolLiteral,
CallExpression,
FunctionTypeLiteral,
FieldAccessExpression,
IndexExpression,
IntTypeLiteral,
ContinuationTypeLiteral, // The type of a continuation value.
IntLiteral,
PatternVariableExpression,
PrimitiveOperatorExpression,
TupleLiteral,
TypeTypeLiteral,
IdentifierExpression,
};
enum class Operator {
@@ -55,124 +55,134 @@ enum class Operator {
struct Expression;
struct Variable {
static constexpr ExpressionKind Kind = ExpressionKind::Variable;
struct IdentifierExpression {
static constexpr ExpressionKind Kind = ExpressionKind::IdentifierExpression;
std::string name;
};
struct FieldAccess {
static constexpr ExpressionKind Kind = ExpressionKind::GetField;
struct FieldAccessExpression {
static constexpr ExpressionKind Kind = ExpressionKind::FieldAccessExpression;
const Expression* aggregate;
std::string field;
};
struct Index {
static constexpr ExpressionKind Kind = ExpressionKind::Index;
struct IndexExpression {
static constexpr ExpressionKind Kind = ExpressionKind::IndexExpression;
const Expression* aggregate;
const Expression* offset;
};
struct PatternVariable {
static constexpr ExpressionKind Kind = ExpressionKind::PatternVariable;
struct PatternVariableExpression {
static constexpr ExpressionKind Kind =
ExpressionKind::PatternVariableExpression;
std::string name;
const Expression* type;
};
struct IntLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::Integer;
static constexpr ExpressionKind Kind = ExpressionKind::IntLiteral;
int value;
};
struct BoolLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::Boolean;
static constexpr ExpressionKind Kind = ExpressionKind::BoolLiteral;
bool value;
};
struct Tuple {
static constexpr ExpressionKind Kind = ExpressionKind::Tuple;
struct TupleLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::TupleLiteral;
std::vector<FieldInitializer> fields;
};
struct PrimitiveOperator {
static constexpr ExpressionKind Kind = ExpressionKind::PrimitiveOp;
struct PrimitiveOperatorExpression {
static constexpr ExpressionKind Kind =
ExpressionKind::PrimitiveOperatorExpression;
Operator op;
std::vector<const Expression*> arguments;
};
struct Call {
static constexpr ExpressionKind Kind = ExpressionKind::Call;
struct CallExpression {
static constexpr ExpressionKind Kind = ExpressionKind::CallExpression;
const Expression* function;
const Expression* argument;
};
struct FunctionType {
static constexpr ExpressionKind Kind = ExpressionKind::FunctionT;
struct FunctionTypeLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::FunctionTypeLiteral;
const Expression* parameter;
const Expression* return_type;
};
struct AutoT {
static constexpr ExpressionKind Kind = ExpressionKind::AutoT;
struct AutoTypeLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::AutoTypeLiteral;
};
struct BoolT {
static constexpr ExpressionKind Kind = ExpressionKind::BoolT;
struct BoolTypeLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::BoolTypeLiteral;
};
struct IntT {
static constexpr ExpressionKind Kind = ExpressionKind::IntT;
struct IntTypeLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::IntTypeLiteral;
};
struct ContinuationT {
static constexpr ExpressionKind Kind = ExpressionKind::ContinuationT;
struct ContinuationTypeLiteral {
static constexpr ExpressionKind Kind =
ExpressionKind::ContinuationTypeLiteral;
};
struct TypeT {
static constexpr ExpressionKind Kind = ExpressionKind::TypeT;
struct TypeTypeLiteral {
static constexpr ExpressionKind Kind = ExpressionKind::TypeTypeLiteral;
};
struct Expression {
int line_num;
inline auto tag() const -> ExpressionKind;
static auto MakeVar(int line_num, std::string var) -> const Expression*;
static auto MakeVarPat(int line_num, std::string var, const Expression* type)
static auto MakeIdentifierExpression(int line_num, std::string var)
-> const Expression*;
static auto MakeInt(int line_num, int i) -> const Expression*;
static auto MakeBool(int line_num, bool b) -> const Expression*;
static auto MakeOp(int line_num, Operator op,
std::vector<const Expression*> args) -> const Expression*;
static auto MakeCall(int line_num, const Expression* fun,
const Expression* arg) -> const Expression*;
static auto MakeGetField(int line_num, const Expression* exp,
std::string field) -> const Expression*;
static auto MakeTuple(int line_num, std::vector<FieldInitializer> args)
static auto MakePatternVariableExpression(int line_num, std::string var,
const Expression* type)
-> const Expression*;
static auto MakeIndex(int line_num, const Expression* exp,
const Expression* i) -> const Expression*;
static auto MakeTypeType(int line_num) -> const Expression*;
static auto MakeIntType(int line_num) -> const Expression*;
static auto MakeBoolType(int line_num) -> const Expression*;
static auto MakeFunType(int line_num, const Expression* param,
const Expression* ret) -> const Expression*;
static auto MakeAutoType(int line_num) -> const Expression*;
static auto MakeContinuationType(int line_num) -> const Expression*;
static auto MakeIntLiteral(int line_num, int i) -> const Expression*;
static auto MakeBoolLiteral(int line_num, bool b) -> const Expression*;
static auto MakePrimitiveOperatorExpression(
int line_num, Operator op, std::vector<const Expression*> args)
-> const Expression*;
static auto MakeCallExpression(int line_num, const Expression* fun,
const Expression* arg) -> const Expression*;
static auto MakeFieldAccessExpression(int line_num, const Expression* exp,
std::string field) -> const Expression*;
static auto MakeTupleLiteral(int line_num, std::vector<FieldInitializer> args)
-> const Expression*;
static auto MakeIndexExpression(int line_num, const Expression* exp,
const Expression* i) -> const Expression*;
static auto MakeTypeTypeLiteral(int line_num) -> const Expression*;
static auto MakeIntTypeLiteral(int line_num) -> const Expression*;
static auto MakeBoolTypeLiteral(int line_num) -> const Expression*;
static auto MakeFunctionTypeLiteral(int line_num, const Expression* param,
const Expression* ret)
-> const Expression*;
static auto MakeAutoTypeLiteral(int line_num) -> const Expression*;
static auto MakeContinuationTypeLiteral(int line_num) -> const Expression*;
auto GetVariable() const -> const Variable&;
auto GetFieldAccess() const -> const FieldAccess&;
auto GetIndex() const -> const Index&;
auto GetPatternVariable() const -> const PatternVariable&;
auto GetInteger() const -> int;
auto GetBoolean() const -> bool;
auto GetTuple() const -> const Tuple&;
auto GetPrimitiveOperator() const -> const PrimitiveOperator&;
auto GetCall() const -> const Call&;
auto GetFunctionType() const -> const FunctionType&;
auto GetIdentifierExpression() const -> const IdentifierExpression&;
auto GetFieldAccessExpression() const -> const FieldAccessExpression&;
auto GetIndexExpression() const -> const IndexExpression&;
auto GetPatternVariableExpression() const -> const PatternVariableExpression&;
auto GetIntLiteral() const -> int;
auto GetBoolLiteral() const -> bool;
auto GetTupleLiteral() const -> const TupleLiteral&;
auto GetPrimitiveOperatorExpression() const
-> const PrimitiveOperatorExpression&;
auto GetCallExpression() const -> const CallExpression&;
auto GetFunctionTypeLiteral() const -> const FunctionTypeLiteral&;
private:
std::variant<Variable, FieldAccess, Index, PatternVariable, IntLiteral,
BoolLiteral, Tuple, PrimitiveOperator, Call, FunctionType, AutoT,
BoolT, IntT, ContinuationT, TypeT>
std::variant<IdentifierExpression, FieldAccessExpression, IndexExpression,
PatternVariableExpression, IntLiteral, BoolLiteral, TupleLiteral,
PrimitiveOperatorExpression, CallExpression, FunctionTypeLiteral,
AutoTypeLiteral, BoolTypeLiteral, IntTypeLiteral,
ContinuationTypeLiteral, TypeTypeLiteral>
value;
};
executable_semantics/interpreter/interpreter.cpp
+216 -203
View File
@@ -66,65 +66,66 @@ void Heap::CheckAlive(Address address, int line_num) {
auto CopyVal(const Value* val, int line_num) -> const Value* {
switch (val->tag) {
case ValKind::TupleV: {
case ValKind::TupleValue: {
auto* elements = new std::vector<TupleElement>();
for (const TupleElement& element : *val->GetTuple().elements) {
for (const TupleElement& element : *val->GetTupleValue().elements) {
const Value* new_element =
CopyVal(state->heap.Read(element.address, line_num), line_num);
Address new_address = state->heap.AllocateValue(new_element);
elements->push_back({.name = element.name, .address = new_address});
}
return Value::MakeTupleVal(elements);
return Value::MakeTupleValue(elements);
}
case ValKind::AltV: {
case ValKind::AlternativeValue: {
const Value* arg = CopyVal(
state->heap.Read(val->GetAlternative().argument, line_num), line_num);
state->heap.Read(val->GetAlternativeValue().argument, line_num),
line_num);
Address argument_address = state->heap.AllocateValue(arg);
return Value::MakeAltVal(*val->GetAlternative().alt_name,
*val->GetAlternative().choice_name,
argument_address);
return Value::MakeAlternativeValue(
*val->GetAlternativeValue().alt_name,
*val->GetAlternativeValue().choice_name, argument_address);
}
case ValKind::StructV: {
const Value* inits = CopyVal(val->GetStruct().inits, line_num);
return Value::MakeStructVal(val->GetStruct().type, inits);
case ValKind::StructValue: {
const Value* inits = CopyVal(val->GetStructValue().inits, line_num);
return Value::MakeStructValue(val->GetStructValue().type, inits);
}
case ValKind::IntV:
return Value::MakeIntVal(val->GetInteger());
case ValKind::BoolV:
return Value::MakeBoolVal(val->GetBoolean());
case ValKind::FunV:
return Value::MakeFunVal(*val->GetFunction().name,
val->GetFunction().param,
val->GetFunction().body);
case ValKind::PtrV:
return Value::MakePtrVal(val->GetPointer());
case ValKind::ContinuationV:
case ValKind::IntValue:
return Value::MakeIntValue(val->GetIntValue());
case ValKind::BoolValue:
return Value::MakeBoolValue(val->GetBoolValue());
case ValKind::FunctionValue:
return Value::MakeFunctionValue(*val->GetFunctionValue().name,
val->GetFunctionValue().param,
val->GetFunctionValue().body);
case ValKind::PointerValue:
return Value::MakePointerValue(val->GetPointerValue());
case ValKind::ContinuationValue:
// Copying a continuation is "shallow".
return val;
case ValKind::FunctionTV:
return Value::MakeFunTypeVal(
case ValKind::FunctionType:
return Value::MakeFunctionType(
CopyVal(val->GetFunctionType().param, line_num),
CopyVal(val->GetFunctionType().ret, line_num));
case ValKind::PointerTV:
return Value::MakePtrTypeVal(
case ValKind::PointerType:
return Value::MakePointerType(
CopyVal(val->GetPointerType().type, line_num));
case ValKind::IntTV:
return Value::MakeIntTypeVal();
case ValKind::BoolTV:
return Value::MakeBoolTypeVal();
case ValKind::TypeTV:
return Value::MakeTypeTypeVal();
case ValKind::IntType:
return Value::MakeIntType();
case ValKind::BoolType:
return Value::MakeBoolType();
case ValKind::TypeType:
return Value::MakeTypeType();
case ValKind::VarTV:
return Value::MakeVarTypeVal(*val->GetVariableType());
case ValKind::AutoTV:
return Value::MakeAutoTypeVal();
case ValKind::ContinuationTV:
return Value::MakeContinuationTypeVal();
case ValKind::StructTV:
case ValKind::ChoiceTV:
case ValKind::VarPatV:
case ValKind::AltConsV:
case ValKind::AutoType:
return Value::MakeAutoType();
case ValKind::ContinuationType:
return Value::MakeContinuationType();
case ValKind::StructType:
case ValKind::ChoiceType:
case ValKind::PatternVariableValue:
case ValKind::AlternativeConstructorValue:
return val; // no need to copy these because they are immutable?
// No, they need to be copied so they don't get killed. -Jeremy
}
@@ -132,14 +133,14 @@ auto CopyVal(const Value* val, int line_num) -> const Value* {
void Heap::DeallocateSubObjects(const Value* val) {
switch (val->tag) {
case ValKind::AltV:
Deallocate(val->GetAlternative().argument);
case ValKind::AlternativeValue:
Deallocate(val->GetAlternativeValue().argument);
break;
case ValKind::StructV:
DeallocateSubObjects(val->GetStruct().inits);
case ValKind::StructValue:
DeallocateSubObjects(val->GetStructValue().inits);
break;
case ValKind::TupleV:
for (const TupleElement& element : *val->GetTuple().elements) {
case ValKind::TupleValue:
for (const TupleElement& element : *val->GetTupleValue().elements) {
Deallocate(element.address);
}
break;
@@ -226,8 +227,8 @@ void PrintState(std::ostream& out) {
auto ValToInt(const Value* v, int line_num) -> int {
switch (v->tag) {
case ValKind::IntV:
return v->GetInteger();
case ValKind::IntValue:
return v->GetIntValue();
default:
std::cerr << line_num << ": runtime error: expected an integer"
<< std::endl;
@@ -237,8 +238,8 @@ auto ValToInt(const Value* v, int line_num) -> int {
auto ValToBool(const Value* v, int line_num) -> int {
switch (v->tag) {
case ValKind::BoolV:
return v->GetBoolean();
case ValKind::BoolValue:
return v->GetBoolValue();
default:
std::cerr << "runtime type error: expected a Boolean" << std::endl;
exit(-1);
@@ -247,8 +248,8 @@ auto ValToBool(const Value* v, int line_num) -> int {
auto ValToPtr(const Value* v, int line_num) -> Address {
switch (v->tag) {
case ValKind::PtrV:
return v->GetPointer();
case ValKind::PointerValue:
return v->GetPointerValue();
default:
std::cerr << "runtime type error: expected a pointer, not ";
PrintValue(v, std::cerr);
@@ -262,8 +263,8 @@ auto ValToPtr(const Value* v, int line_num) -> Address {
// - Precondition: continuation->tag == ValKind::ContinuationV.
auto ContinuationToVector(const Value* continuation, int sourceLocation)
-> std::vector<Frame*> {
if (continuation->tag == ValKind::ContinuationV) {
return *continuation->GetContinuation().stack;
if (continuation->tag == ValKind::ContinuationValue) {
return *continuation->GetContinuationValue().stack;
} else {
std::cerr << sourceLocation << ": runtime error: expected an integer"
<< std::endl;
@@ -275,28 +276,28 @@ auto EvalPrim(Operator op, const std::vector<const Value*>& args, int line_num)
-> const Value* {
switch (op) {
case Operator::Neg:
return Value::MakeIntVal(-ValToInt(args[0], line_num));
return Value::MakeIntValue(-ValToInt(args[0], line_num));
case Operator::Add:
return Value::MakeIntVal(ValToInt(args[0], line_num) +
ValToInt(args[1], line_num));
return Value::MakeIntValue(ValToInt(args[0], line_num) +
ValToInt(args[1], line_num));
case Operator::Sub:
return Value::MakeIntVal(ValToInt(args[0], line_num) -
ValToInt(args[1], line_num));
return Value::MakeIntValue(ValToInt(args[0], line_num) -
ValToInt(args[1], line_num));
case Operator::Mul:
return Value::MakeIntVal(ValToInt(args[0], line_num) *
ValToInt(args[1], line_num));
return Value::MakeIntValue(ValToInt(args[0], line_num) *
ValToInt(args[1], line_num));
case Operator::Not:
return Value::MakeBoolVal(!ValToBool(args[0], line_num));
return Value::MakeBoolValue(!ValToBool(args[0], line_num));
case Operator::And:
return Value::MakeBoolVal(ValToBool(args[0], line_num) &&
ValToBool(args[1], line_num));
return Value::MakeBoolValue(ValToBool(args[0], line_num) &&
ValToBool(args[1], line_num));
case Operator::Or:
return Value::MakeBoolVal(ValToBool(args[0], line_num) ||
ValToBool(args[1], line_num));
return Value::MakeBoolValue(ValToBool(args[0], line_num) ||
ValToBool(args[1], line_num));
case Operator::Eq:
return Value::MakeBoolVal(ValueEqual(args[0], args[1], line_num));
return Value::MakeBoolValue(ValueEqual(args[0], args[1], line_num));
case Operator::Ptr:
return Value::MakePtrTypeVal(args[0]);
return Value::MakePointerType(args[0]);
case Operator::Deref:
std::cerr << line_num << ": dereference not implemented yet\n";
exit(-1);
@@ -318,7 +319,7 @@ auto ChoiceDeclaration::InitGlobals(Env& globals) const -> void {
auto t = InterpExp(Env(), signature);
alts->push_back(make_pair(name, t));
}
auto ct = Value::MakeChoiceTypeVal(name, alts);
auto ct = Value::MakeChoiceType(name, alts);
auto a = state->heap.AllocateValue(ct);
globals.Set(name, a);
}
@@ -336,14 +337,14 @@ auto StructDeclaration::InitGlobals(Env& globals) const -> void {
}
}
}
auto st = Value::MakeStructTypeVal(*definition.name, fields, methods);
auto st = Value::MakeStructType(*definition.name, fields, methods);
auto a = state->heap.AllocateValue(st);
globals.Set(*definition.name, a);
}
auto FunctionDeclaration::InitGlobals(Env& globals) const -> void {
auto pt = InterpExp(globals, definition.param_pattern);
auto f = Value::MakeFunVal(definition.name, pt, definition.body);
auto f = Value::MakeFunctionValue(definition.name, pt, definition.body);
Address a = state->heap.AllocateValue(f);
globals.Set(definition.name, a);
}
@@ -363,11 +364,11 @@ auto VariableDeclaration::InitGlobals(Env& globals) const -> void {
void CallFunction(int line_num, std::vector<const Value*> operas,
State* state) {
switch (operas[0]->tag) {
case ValKind::FunV: {
case ValKind::FunctionValue: {
// Bind arguments to parameters
std::list<std::string> params;
std::optional<Env> matches =
PatternMatch(operas[0]->GetFunction().param, operas[1], globals,
PatternMatch(operas[0]->GetFunctionValue().param, operas[1], globals,
&params, line_num);
if (!matches) {
std::cerr << "internal error in call_function, pattern match failed"
@@ -377,24 +378,24 @@ void CallFunction(int line_num, std::vector<const Value*> operas,
// Create the new frame and push it on the stack
auto* scope = new Scope(*matches, params);
auto* frame =
new Frame(*operas[0]->GetFunction().name, Stack(scope),
Stack(MakeStmtAct(operas[0]->GetFunction().body)));
new Frame(*operas[0]->GetFunctionValue().name, Stack(scope),
Stack(MakeStmtAct(operas[0]->GetFunctionValue().body)));
state->stack.Push(frame);
break;
}
case ValKind::StructTV: {
case ValKind::StructType: {
const Value* arg = CopyVal(operas[1], line_num);
const Value* sv = Value::MakeStructVal(operas[0], arg);
const Value* sv = Value::MakeStructValue(operas[0], arg);
Frame* frame = state->stack.Top();
frame->todo.Push(MakeValAct(sv));
break;
}
case ValKind::AltConsV: {
case ValKind::AlternativeConstructorValue: {
const Value* arg = CopyVal(operas[1], line_num);
const Value* av =
Value::MakeAltVal(*operas[0]->GetAlternativeConstructor().alt_name,
*operas[0]->GetAlternativeConstructor().choice_name,
state->heap.AllocateValue(arg));
const Value* av = Value::MakeAlternativeValue(
*operas[0]->GetAlternativeConstructorValue().alt_name,
*operas[0]->GetAlternativeConstructorValue().choice_name,
state->heap.AllocateValue(arg));
Frame* frame = state->stack.Top();
frame->todo.Push(MakeValAct(av));
break;
@@ -428,12 +429,12 @@ void CreateTuple(Frame* frame, Action* act, const Expression* /*exp*/) {
// { { (v1,...,vn) :: C, E, F} :: S, H}
// -> { { `(v1,...,vn) :: C, E, F} :: S, H}
auto elements = new std::vector<TupleElement>();
auto f = act->u.exp->GetTuple().fields.begin();
auto f = act->u.exp->GetTupleLiteral().fields.begin();
for (auto i = act->results.begin(); i != act->results.end(); ++i, ++f) {
Address a = state->heap.AllocateValue(*i); // copy?
elements->push_back({.name = f->name, .address = a});
}
const Value* tv = Value::MakeTupleVal(elements);
const Value* tv = Value::MakeTupleValue(elements);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(tv));
}
@@ -447,22 +448,22 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
std::list<std::string>* vars, int line_num)
-> std::optional<Env> {
switch (p->tag) {
case ValKind::VarPatV: {
case ValKind::PatternVariableValue: {
Address a = state->heap.AllocateValue(CopyVal(v, line_num));
vars->push_back(*p->GetVariablePattern().name);
values.Set(*p->GetVariablePattern().name, a);
vars->push_back(*p->GetPatternVariableValue().name);
values.Set(*p->GetPatternVariableValue().name, a);
return values;
}
case ValKind::TupleV:
case ValKind::TupleValue:
switch (v->tag) {
case ValKind::TupleV: {
if (p->GetTuple().elements->size() !=
v->GetTuple().elements->size()) {
case ValKind::TupleValue: {
if (p->GetTupleValue().elements->size() !=
v->GetTupleValue().elements->size()) {
std::cerr << "runtime error: arity mismatch in tuple pattern match"
<< std::endl;
exit(-1);
}
for (const TupleElement& element : *p->GetTuple().elements) {
for (const TupleElement& element : *p->GetTupleValue().elements) {
auto a = FindTupleField(element.name, v);
if (a == std::nullopt) {
std::cerr << "runtime error: field " << element.name << "not in ";
@@ -487,18 +488,19 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
std::cerr << std::endl;
exit(-1);
}
case ValKind::AltV:
case ValKind::AlternativeValue:
switch (v->tag) {
case ValKind::AltV: {
if (*p->GetAlternative().choice_name !=
*v->GetAlternative().choice_name ||
*p->GetAlternative().alt_name != *v->GetAlternative().alt_name) {
case ValKind::AlternativeValue: {
if (*p->GetAlternativeValue().choice_name !=
*v->GetAlternativeValue().choice_name ||
*p->GetAlternativeValue().alt_name !=
*v->GetAlternativeValue().alt_name) {
return std::nullopt;
}
std::optional<Env> matches = PatternMatch(
state->heap.Read(p->GetAlternative().argument, line_num),
state->heap.Read(v->GetAlternative().argument, line_num), values,
vars, line_num);
state->heap.Read(p->GetAlternativeValue().argument, line_num),
state->heap.Read(v->GetAlternativeValue().argument, line_num),
values, vars, line_num);
if (!matches) {
return std::nullopt;
}
@@ -512,9 +514,9 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
std::cerr << std::endl;
exit(-1);
}
case ValKind::FunctionTV:
case ValKind::FunctionType:
switch (v->tag) {
case ValKind::FunctionTV: {
case ValKind::FunctionType: {
std::optional<Env> matches =
PatternMatch(p->GetFunctionType().param,
v->GetFunctionType().param, values, vars, line_num);
@@ -539,20 +541,20 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
void PatternAssignment(const Value* pat, const Value* val, int line_num) {
switch (pat->tag) {
case ValKind::PtrV:
case ValKind::PointerValue:
state->heap.Write(ValToPtr(pat, line_num), CopyVal(val, line_num),
line_num);
break;
case ValKind::TupleV: {
case ValKind::TupleValue: {
switch (val->tag) {
case ValKind::TupleV: {
if (pat->GetTuple().elements->size() !=
val->GetTuple().elements->size()) {
case ValKind::TupleValue: {
if (pat->GetTupleValue().elements->size() !=
val->GetTupleValue().elements->size()) {
std::cerr << "runtime error: arity mismatch in tuple pattern match"
<< std::endl;
exit(-1);
}
for (const TupleElement& element : *pat->GetTuple().elements) {
for (const TupleElement& element : *pat->GetTupleValue().elements) {
auto a = FindTupleField(element.name, val);
if (a == std::nullopt) {
std::cerr << "runtime error: field " << element.name << "not in ";
@@ -575,19 +577,19 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
}
break;
}
case ValKind::AltV: {
case ValKind::AlternativeValue: {
switch (val->tag) {
case ValKind::AltV: {
if (*pat->GetAlternative().choice_name !=
*val->GetAlternative().choice_name ||
*pat->GetAlternative().alt_name !=
*val->GetAlternative().alt_name) {
case ValKind::AlternativeValue: {
if (*pat->GetAlternativeValue().choice_name !=
*val->GetAlternativeValue().choice_name ||
*pat->GetAlternativeValue().alt_name !=
*val->GetAlternativeValue().alt_name) {
std::cerr << "internal error in pattern assignment" << std::endl;
exit(-1);
}
PatternAssignment(
state->heap.Read(pat->GetAlternative().argument, line_num),
state->heap.Read(val->GetAlternative().argument, line_num),
state->heap.Read(pat->GetAlternativeValue().argument, line_num),
state->heap.Read(val->GetAlternativeValue().argument, line_num),
line_num);
break;
}
@@ -621,46 +623,48 @@ void StepLvalue() {
std::cout << " --->" << std::endl;
}
switch (exp->tag()) {
case ExpressionKind::Variable: {
case ExpressionKind::IdentifierExpression: {
// { {x :: C, E, F} :: S, H}
// -> { {E(x) :: C, E, F} :: S, H}
std::optional<Address> pointer =
CurrentEnv(state).Get(exp->GetVariable().name);
CurrentEnv(state).Get(exp->GetIdentifierExpression().name);
if (!pointer) {
std::cerr << exp->line_num << ": could not find `"
<< exp->GetVariable().name << "`" << std::endl;
<< exp->GetIdentifierExpression().name << "`" << std::endl;
exit(-1);
}
const Value* v = Value::MakePtrVal(*pointer);
const Value* v = Value::MakePointerValue(*pointer);
frame->todo.Pop();
frame->todo.Push(MakeValAct(v));
break;
}
case ExpressionKind::GetField: {
case ExpressionKind::FieldAccessExpression: {
if (act->pos == 0) {
// { {e.f :: C, E, F} :: S, H}
// -> { e :: [].f :: C, E, F} :: S, H}
frame->todo.Push(MakeLvalAct(exp->GetFieldAccess().aggregate));
frame->todo.Push(
MakeLvalAct(exp->GetFieldAccessExpression().aggregate));
act->pos++;
} else {
// { v :: [].f :: C, E, F} :: S, H}
// -> { { &v.f :: C, E, F} :: S, H }
const Value* str = act->results[0];
Address a = GetMember(ValToPtr(str, exp->line_num),
exp->GetFieldAccess().field, exp->line_num);
Address a =
GetMember(ValToPtr(str, exp->line_num),
exp->GetFieldAccessExpression().field, exp->line_num);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(Value::MakePtrVal(a)));
frame->todo.Push(MakeValAct(Value::MakePointerValue(a)));
}
break;
}
case ExpressionKind::Index: {
case ExpressionKind::IndexExpression: {
if (act->pos == 0) {
// { {e[i] :: C, E, F} :: S, H}
// -> { e :: [][i] :: C, E, F} :: S, H}
frame->todo.Push(MakeExpAct(exp->GetIndex().aggregate));
frame->todo.Push(MakeExpAct(exp->GetIndexExpression().aggregate));
act->pos++;
} else if (act->pos == 1) {
frame->todo.Push(MakeExpAct(exp->GetIndex().offset));
frame->todo.Push(MakeExpAct(exp->GetIndexExpression().offset));
act->pos++;
} else if (act->pos == 2) {
// { v :: [][i] :: C, E, F} :: S, H}
@@ -675,23 +679,25 @@ void StepLvalue() {
exit(-1);
}
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(Value::MakePtrVal(*a)));
frame->todo.Push(MakeValAct(Value::MakePointerValue(*a)));
}
break;
}
case ExpressionKind::Tuple: {
case ExpressionKind::TupleLiteral: {
if (act->pos == 0) {
// { {(f1=e1,...) :: C, E, F} :: S, H}
// -> { {e1 :: (f1=[],...) :: C, E, F} :: S, H}
const Expression* e1 = exp->GetTuple().fields[0].expression;
const Expression* e1 = exp->GetTupleLiteral().fields[0].expression;
frame->todo.Push(MakeLvalAct(e1));
act->pos++;
} else if (act->pos != static_cast<int>(exp->GetTuple().fields.size())) {
} else if (act->pos !=
static_cast<int>(exp->GetTupleLiteral().fields.size())) {
// { { vk :: (f1=v1,..., fk=[],fk+1=ek+1,...) :: C, E, F} :: S,
// H}
// -> { { ek+1 :: (f1=v1,..., fk=vk, fk+1=[],...) :: C, E, F} :: S,
// H}
const Expression* elt = exp->GetTuple().fields[act->pos].expression;
const Expression* elt =
exp->GetTupleLiteral().fields[act->pos].expression;
frame->todo.Push(MakeLvalAct(elt));
act->pos++;
} else {
@@ -699,17 +705,17 @@ void StepLvalue() {
}
break;
}
case ExpressionKind::Integer:
case ExpressionKind::Boolean:
case ExpressionKind::Call:
case ExpressionKind::PrimitiveOp:
case ExpressionKind::IntT:
case ExpressionKind::BoolT:
case ExpressionKind::TypeT:
case ExpressionKind::FunctionT:
case ExpressionKind::AutoT:
case ExpressionKind::ContinuationT:
case ExpressionKind::PatternVariable: {
case ExpressionKind::IntLiteral:
case ExpressionKind::BoolLiteral:
case ExpressionKind::CallExpression:
case ExpressionKind::PrimitiveOperatorExpression:
case ExpressionKind::IntTypeLiteral:
case ExpressionKind::BoolTypeLiteral:
case ExpressionKind::TypeTypeLiteral:
case ExpressionKind::FunctionTypeLiteral:
case ExpressionKind::AutoTypeLiteral:
case ExpressionKind::ContinuationTypeLiteral:
case ExpressionKind::PatternVariableExpression: {
frame->todo.Pop();
frame->todo.Push(MakeExpToLvalAct());
frame->todo.Push(MakeExpAct(exp));
@@ -729,31 +735,31 @@ void StepExp() {
std::cout << " --->" << std::endl;
}
switch (exp->tag()) {
case ExpressionKind::PatternVariable: {
case ExpressionKind::PatternVariableExpression: {
if (act->pos == 0) {
frame->todo.Push(MakeExpAct(exp->GetPatternVariable().type));
frame->todo.Push(MakeExpAct(exp->GetPatternVariableExpression().type));
act->pos++;
} else {
auto v = Value::MakeVarPatVal(exp->GetPatternVariable().name,
act->results[0]);
auto v = Value::MakePatternVariableValue(
exp->GetPatternVariableExpression().name, act->results[0]);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
}
break;
}
case ExpressionKind::Index: {
case ExpressionKind::IndexExpression: {
if (act->pos == 0) {
// { { e[i] :: C, E, F} :: S, H}
// -> { { e :: [][i] :: C, E, F} :: S, H}
frame->todo.Push(MakeExpAct(exp->GetIndex().aggregate));
frame->todo.Push(MakeExpAct(exp->GetIndexExpression().aggregate));
act->pos++;
} else if (act->pos == 1) {
frame->todo.Push(MakeExpAct(exp->GetIndex().offset));
frame->todo.Push(MakeExpAct(exp->GetIndexExpression().offset));
act->pos++;
} else if (act->pos == 2) {
auto tuple = act->results[0];
switch (tuple->tag) {
case ValKind::TupleV: {
case ValKind::TupleValue: {
// { { v :: [][i] :: C, E, F} :: S, H}
// -> { { v_i :: C, E, F} : S, H}
std::string f = std::to_string(ToInteger(act->results[1]));
@@ -779,23 +785,25 @@ void StepExp() {
}
break;
}
case ExpressionKind::Tuple: {
case ExpressionKind::TupleLiteral: {
if (act->pos == 0) {
if (exp->GetTuple().fields.size() > 0) {
if (exp->GetTupleLiteral().fields.size() > 0) {
// { {(f1=e1,...) :: C, E, F} :: S, H}
// -> { {e1 :: (f1=[],...) :: C, E, F} :: S, H}
const Expression* e1 = exp->GetTuple().fields[0].expression;
const Expression* e1 = exp->GetTupleLiteral().fields[0].expression;
frame->todo.Push(MakeExpAct(e1));
act->pos++;
} else {
CreateTuple(frame, act, exp);
}
} else if (act->pos != static_cast<int>(exp->GetTuple().fields.size())) {
} else if (act->pos !=
static_cast<int>(exp->GetTupleLiteral().fields.size())) {
// { { vk :: (f1=v1,..., fk=[],fk+1=ek+1,...) :: C, E, F} :: S,
// H}
// -> { { ek+1 :: (f1=v1,..., fk=vk, fk+1=[],...) :: C, E, F} :: S,
// H}
const Expression* elt = exp->GetTuple().fields[act->pos].expression;
const Expression* elt =
exp->GetTupleLiteral().fields[act->pos].expression;
frame->todo.Push(MakeExpAct(elt));
act->pos++;
} else {
@@ -803,31 +811,33 @@ void StepExp() {
}
break;
}
case ExpressionKind::GetField: {
case ExpressionKind::FieldAccessExpression: {
if (act->pos == 0) {
// { { e.f :: C, E, F} :: S, H}
// -> { { e :: [].f :: C, E, F} :: S, H}
frame->todo.Push(MakeLvalAct(exp->GetFieldAccess().aggregate));
frame->todo.Push(
MakeLvalAct(exp->GetFieldAccessExpression().aggregate));
act->pos++;
} else {
// { { v :: [].f :: C, E, F} :: S, H}
// -> { { v_f :: C, E, F} : S, H}
auto a = GetMember(ValToPtr(act->results[0], exp->line_num),
exp->GetFieldAccess().field, exp->line_num);
auto a =
GetMember(ValToPtr(act->results[0], exp->line_num),
exp->GetFieldAccessExpression().field, exp->line_num);
const Value* element = state->heap.Read(a, exp->line_num);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(element));
}
break;
}
case ExpressionKind::Variable: {
case ExpressionKind::IdentifierExpression: {
CHECK(act->pos == 0);
// { {x :: C, E, F} :: S, H} -> { {H(E(x)) :: C, E, F} :: S, H}
std::optional<Address> pointer =
CurrentEnv(state).Get(exp->GetVariable().name);
CurrentEnv(state).Get(exp->GetIdentifierExpression().name);
if (!pointer) {
std::cerr << exp->line_num << ": could not find `"
<< exp->GetVariable().name << "`" << std::endl;
<< exp->GetIdentifierExpression().name << "`" << std::endl;
exit(-1);
}
const Value* pointee = state->heap.Read(*pointer, exp->line_num);
@@ -835,45 +845,47 @@ void StepExp() {
frame->todo.Push(MakeValAct(pointee));
break;
}
case ExpressionKind::Integer:
case ExpressionKind::IntLiteral:
CHECK(act->pos == 0);
// { {n :: C, E, F} :: S, H} -> { {n' :: C, E, F} :: S, H}
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(Value::MakeIntVal(exp->GetInteger())));
frame->todo.Push(MakeValAct(Value::MakeIntValue(exp->GetIntLiteral())));
break;
case ExpressionKind::Boolean:
case ExpressionKind::BoolLiteral:
CHECK(act->pos == 0);
// { {n :: C, E, F} :: S, H} -> { {n' :: C, E, F} :: S, H}
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(Value::MakeBoolVal(exp->GetBoolean())));
frame->todo.Push(MakeValAct(Value::MakeBoolValue(exp->GetBoolLiteral())));
break;
case ExpressionKind::PrimitiveOp:
case ExpressionKind::PrimitiveOperatorExpression:
if (act->pos !=
static_cast<int>(exp->GetPrimitiveOperator().arguments.size())) {
static_cast<int>(
exp->GetPrimitiveOperatorExpression().arguments.size())) {
// { {v :: op(vs,[],e,es) :: C, E, F} :: S, H}
// -> { {e :: op(vs,v,[],es) :: C, E, F} :: S, H}
const Expression* arg = exp->GetPrimitiveOperator().arguments[act->pos];
const Expression* arg =
exp->GetPrimitiveOperatorExpression().arguments[act->pos];
frame->todo.Push(MakeExpAct(arg));
act->pos++;
} else {
// { {v :: op(vs,[]) :: C, E, F} :: S, H}
// -> { {eval_prim(op, (vs,v)) :: C, E, F} :: S, H}
const Value* v = EvalPrim(exp->GetPrimitiveOperator().op, act->results,
exp->line_num);
const Value* v = EvalPrim(exp->GetPrimitiveOperatorExpression().op,
act->results, exp->line_num);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
}
break;
case ExpressionKind::Call:
case ExpressionKind::CallExpression:
if (act->pos == 0) {
// { {e1(e2) :: C, E, F} :: S, H}
// -> { {e1 :: [](e2) :: C, E, F} :: S, H}
frame->todo.Push(MakeExpAct(exp->GetCall().function));
frame->todo.Push(MakeExpAct(exp->GetCallExpression().function));
act->pos++;
} else if (act->pos == 1) {
// { { v :: [](e) :: C, E, F} :: S, H}
// -> { { e :: v([]) :: C, E, F} :: S, H}
frame->todo.Push(MakeExpAct(exp->GetCall().argument));
frame->todo.Push(MakeExpAct(exp->GetCallExpression().argument));
act->pos++;
} else if (act->pos == 2) {
// { { v2 :: v1([]) :: C, E, F} :: S, H}
@@ -885,56 +897,56 @@ void StepExp() {
exit(-1);
}
break;
case ExpressionKind::IntT: {
case ExpressionKind::IntTypeLiteral: {
CHECK(act->pos == 0);
const Value* v = Value::MakeIntTypeVal();
const Value* v = Value::MakeIntType();
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
break;
}
case ExpressionKind::BoolT: {
case ExpressionKind::BoolTypeLiteral: {
CHECK(act->pos == 0);
const Value* v = Value::MakeBoolTypeVal();
const Value* v = Value::MakeBoolType();
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
break;
}
case ExpressionKind::AutoT: {
case ExpressionKind::AutoTypeLiteral: {
CHECK(act->pos == 0);
const Value* v = Value::MakeAutoTypeVal();
const Value* v = Value::MakeAutoType();
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
break;
}
case ExpressionKind::TypeT: {
case ExpressionKind::TypeTypeLiteral: {
CHECK(act->pos == 0);
const Value* v = Value::MakeTypeTypeVal();
const Value* v = Value::MakeTypeType();
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
break;
}
case ExpressionKind::FunctionT: {
case ExpressionKind::FunctionTypeLiteral: {
if (act->pos == 0) {
frame->todo.Push(MakeExpAct(exp->GetFunctionType().parameter));
frame->todo.Push(MakeExpAct(exp->GetFunctionTypeLiteral().parameter));
act->pos++;
} else if (act->pos == 1) {
// { { pt :: fn [] -> e :: C, E, F} :: S, H}
// -> { { e :: fn pt -> []) :: C, E, F} :: S, H}
frame->todo.Push(MakeExpAct(exp->GetFunctionType().return_type));
frame->todo.Push(MakeExpAct(exp->GetFunctionTypeLiteral().return_type));
act->pos++;
} else if (act->pos == 2) {
// { { rt :: fn pt -> [] :: C, E, F} :: S, H}
// -> { fn pt -> rt :: {C, E, F} :: S, H}
const Value* v =
Value::MakeFunTypeVal(act->results[0], act->results[1]);
Value::MakeFunctionType(act->results[0], act->results[1]);
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
}
break;
}
case ExpressionKind::ContinuationT: {
case ExpressionKind::ContinuationTypeLiteral: {
CHECK(act->pos == 0);
const Value* v = Value::MakeContinuationTypeVal();
const Value* v = Value::MakeContinuationType();
frame->todo.Pop(1);
frame->todo.Push(MakeValAct(v));
break;
@@ -1223,11 +1235,11 @@ void StepStmt() {
scopes.Push(scope);
Stack<Action*> todo;
todo.Push(MakeStmtAct(Statement::MakeReturn(
stmt->line_num, Expression::MakeTuple(stmt->line_num, {}))));
stmt->line_num, Expression::MakeTupleLiteral(stmt->line_num, {}))));
todo.Push(MakeStmtAct(stmt->GetContinuation().body));
Frame* continuation_frame = new Frame("__continuation", scopes, todo);
Address continuation_address = state->heap.AllocateValue(
Value::MakeContinuation({continuation_frame}));
Value::MakeContinuationValue({continuation_frame}));
// Store the continuation's address in the frame.
continuation_frame->continuation = continuation_address;
// Bind the continuation object to the continuation variable
@@ -1247,7 +1259,7 @@ void StepStmt() {
// Push an expression statement action to ignore the result
// value from the continuation.
Action* ignore_result = MakeStmtAct(Statement::MakeExpStmt(
stmt->line_num, Expression::MakeTuple(stmt->line_num, {})));
stmt->line_num, Expression::MakeTupleLiteral(stmt->line_num, {})));
ignore_result->pos = 0;
frame->todo.Push(ignore_result);
// Push the continuation onto the current stack.
@@ -1269,7 +1281,7 @@ void StepStmt() {
} while (!paused.back()->IsContinuation());
// Update the continuation with the paused stack.
state->heap.Write(paused.back()->continuation,
Value::MakeContinuation(paused), stmt->line_num);
Value::MakeContinuationValue(paused), stmt->line_num);
break;
}
}
@@ -1277,8 +1289,8 @@ void StepStmt() {
auto GetMember(Address a, const std::string& f, int line_num) -> Address {
const Value* v = state->heap.Read(a, line_num);
switch (v->tag) {
case ValKind::StructV: {
auto a = FindTupleField(f, v->GetStruct().inits);
case ValKind::StructValue: {
auto a = FindTupleField(f, v->GetStructValue().inits);
if (a == std::nullopt) {
std::cerr << "runtime error, member " << f << " not in ";
PrintValue(v, std::cerr);
@@ -1287,7 +1299,7 @@ auto GetMember(Address a, const std::string& f, int line_num) -> Address {
}
return *a;
}
case ValKind::TupleV: {
case ValKind::TupleValue: {
auto a = FindTupleField(f, v);
if (a == std::nullopt) {
std::cerr << "field " << f << " not in ";
@@ -1297,14 +1309,15 @@ auto GetMember(Address a, const std::string& f, int line_num) -> Address {
}
return *a;
}
case ValKind::ChoiceTV: {
case ValKind::ChoiceType: {
if (FindInVarValues(f, v->GetChoiceType().alternatives) == nullptr) {
std::cerr << "alternative " << f << " not in ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
exit(-1);
}
auto ac = Value::MakeAltCons(f, *v->GetChoiceType().name);
auto ac =
Value::MakeAlternativeConstructorValue(f, *v->GetChoiceType().name);
return state->heap.AllocateValue(ac);
}
default:
@@ -1361,7 +1374,7 @@ void Step() {
auto del = MakeDeleteAct(a);
frame->todo.Pop(1);
InsertDelete(del, frame->todo);
frame->todo.Push(MakeValAct(Value::MakePtrVal(a)));
frame->todo.Push(MakeValAct(Value::MakePointerValue(a)));
break;
}
case ActionKind::ValAction: {
@@ -1390,9 +1403,9 @@ auto InterpProgram(std::list<Declaration>* fs) -> int {
}
InitGlobals(fs);
const Expression* arg = Expression::MakeTuple(0, {});
const Expression* call_main =
Expression::MakeCall(0, Expression::MakeVar(0, "main"), arg);
const Expression* arg = Expression::MakeTupleLiteral(0, {});
const Expression* call_main = Expression::MakeCallExpression(
0, Expression::MakeIdentifierExpression(0, "main"), arg);
auto todo = Stack(MakeExpAct(call_main));
auto* scope = new Scope(globals, std::list<std::string>());
auto* frame = new Frame("top", Stack(scope), todo);
executable_semantics/interpreter/typecheck.cpp
+152 -150
View File
@@ -32,7 +32,7 @@ void ExpectType(int line_num, const std::string& context, const Value* expected,
void ExpectPointerType(int line_num, const std::string& context,
const Value* actual) {
if (actual->tag != ValKind::PointerTV) {
if (actual->tag != ValKind::PointerType) {
std::cerr << line_num << ": type error in " << context << std::endl;
std::cerr << "expected a pointer type\n";
std::cerr << "actual: ";
@@ -56,35 +56,35 @@ void PrintTypeEnv(TypeEnv types, std::ostream& out) {
auto ReifyType(const Value* t, int line_num) -> const Expression* {
switch (t->tag) {
case ValKind::VarTV:
return Expression::MakeVar(0, *t->GetVariableType());
case ValKind::IntTV:
return Expression::MakeIntType(0);
case ValKind::BoolTV:
return Expression::MakeBoolType(0);
case ValKind::TypeTV:
return Expression::MakeTypeType(0);
case ValKind::ContinuationTV:
return Expression::MakeContinuationType(0);
case ValKind::FunctionTV:
return Expression::MakeFunType(
return Expression::MakeIdentifierExpression(0, *t->GetVariableType());
case ValKind::IntType:
return Expression::MakeIntTypeLiteral(0);
case ValKind::BoolType:
return Expression::MakeBoolTypeLiteral(0);
case ValKind::TypeType:
return Expression::MakeTypeTypeLiteral(0);
case ValKind::ContinuationType:
return Expression::MakeContinuationTypeLiteral(0);
case ValKind::FunctionType:
return Expression::MakeFunctionTypeLiteral(
0, ReifyType(t->GetFunctionType().param, line_num),
ReifyType(t->GetFunctionType().ret, line_num));
case ValKind::TupleV: {
case ValKind::TupleValue: {
std::vector<FieldInitializer> args;
for (const TupleElement& field : *t->GetTuple().elements) {
for (const TupleElement& field : *t->GetTupleValue().elements) {
args.push_back(
{.name = field.name,
.expression = ReifyType(state->heap.Read(field.address, line_num),
line_num)});
}
return Expression::MakeTuple(0, args);
return Expression::MakeTupleLiteral(0, args);
}
case ValKind::StructTV:
return Expression::MakeVar(0, *t->GetStructType().name);
case ValKind::ChoiceTV:
return Expression::MakeVar(0, *t->GetChoiceType().name);
case ValKind::PointerTV:
return Expression::MakeOp(
case ValKind::StructType:
return Expression::MakeIdentifierExpression(0, *t->GetStructType().name);
case ValKind::ChoiceType:
return Expression::MakeIdentifierExpression(0, *t->GetChoiceType().name);
case ValKind::PointerType:
return Expression::MakePrimitiveOperatorExpression(
0, Operator::Ptr, {ReifyType(t->GetPointerType().type, line_num)});
default:
std::cerr << line_num << ": expected a type, not ";
@@ -135,7 +135,7 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
std::cout << std::endl;
}
switch (e->tag()) {
case ExpressionKind::PatternVariable: {
case ExpressionKind::PatternVariableExpression: {
if (context != TCContext::PatternContext) {
std::cerr
<< e->line_num
@@ -144,8 +144,8 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
<< std::endl;
exit(-1);
}
auto t = InterpExp(values, e->GetPatternVariable().type);
if (t->tag == ValKind::AutoTV) {
auto t = InterpExp(values, e->GetPatternVariableExpression().type);
if (t->tag == ValKind::AutoType) {
if (expected == nullptr) {
std::cerr << e->line_num
<< ": compilation error, auto not allowed here"
@@ -157,18 +157,19 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
} else if (expected) {
ExpectType(e->line_num, "pattern variable", t, expected);
}
auto new_e = Expression::MakeVarPat(
e->line_num, e->GetPatternVariable().name, ReifyType(t, e->line_num));
types.Set(e->GetPatternVariable().name, t);
auto new_e = Expression::MakePatternVariableExpression(
e->line_num, e->GetPatternVariableExpression().name,
ReifyType(t, e->line_num));
types.Set(e->GetPatternVariableExpression().name, t);
return TCResult(new_e, t, types);
}
case ExpressionKind::Index: {
auto res = TypeCheckExp(e->GetIndex().aggregate, types, values, nullptr,
TCContext::ValueContext);
case ExpressionKind::IndexExpression: {
auto res = TypeCheckExp(e->GetIndexExpression().aggregate, types, values,
nullptr, TCContext::ValueContext);
auto t = res.type;
switch (t->tag) {
case ValKind::TupleV: {
auto i = ToInteger(InterpExp(values, e->GetIndex().offset));
case ValKind::TupleValue: {
auto i = ToInteger(InterpExp(values, e->GetIndexExpression().offset));
std::string f = std::to_string(i);
std::optional<Address> field_address = FindTupleField(f, t);
if (field_address == std::nullopt) {
@@ -179,8 +180,8 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
exit(-1);
}
auto field_t = state->heap.Read(*field_address, e->line_num);
auto new_e = Expression::MakeIndex(
e->line_num, res.exp, Expression::MakeInt(e->line_num, i));
auto new_e = Expression::MakeIndexExpression(
e->line_num, res.exp, Expression::MakeIntLiteral(e->line_num, i));
return TCResult(new_e, field_t, res.types);
}
default:
@@ -189,36 +190,37 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
exit(-1);
}
}
case ExpressionKind::Tuple: {
case ExpressionKind::TupleLiteral: {
std::vector<FieldInitializer> new_args;
auto arg_types = new std::vector<TupleElement>();
auto new_types = types;
if (expected && expected->tag != ValKind::TupleV) {
if (expected && expected->tag != ValKind::TupleValue) {
std::cerr << e->line_num << ": compilation error, didn't expect a tuple"
<< std::endl;
exit(-1);
}
if (expected && e->GetTuple().fields.size() !=
expected->GetTuple().elements->size()) {
if (expected && e->GetTupleLiteral().fields.size() !=
expected->GetTupleValue().elements->size()) {
std::cerr << e->line_num
<< ": compilation error, tuples of different length"
<< std::endl;
exit(-1);
}
int i = 0;
for (auto arg = e->GetTuple().fields.begin();
arg != e->GetTuple().fields.end(); ++arg, ++i) {
for (auto arg = e->GetTupleLiteral().fields.begin();
arg != e->GetTupleLiteral().fields.end(); ++arg, ++i) {
const Value* arg_expected = nullptr;
if (expected && expected->tag == ValKind::TupleV) {
if ((*expected->GetTuple().elements)[i].name != arg->name) {
if (expected && expected->tag == ValKind::TupleValue) {
if ((*expected->GetTupleValue().elements)[i].name != arg->name) {
std::cerr << e->line_num
<< ": compilation error, field names do not match, "
<< "expected " << (*expected->GetTuple().elements)[i].name
<< "expected "
<< (*expected->GetTupleValue().elements)[i].name
<< " but got " << arg->name << std::endl;
exit(-1);
}
arg_expected = state->heap.Read(
(*expected->GetTuple().elements)[i].address, e->line_num);
(*expected->GetTupleValue().elements)[i].address, e->line_num);
}
auto arg_res = TypeCheckExp(arg->expression, new_types, values,
arg_expected, context);
@@ -228,42 +230,42 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
{.name = arg->name,
.address = state->heap.AllocateValue(arg_res.type)});
}
auto tuple_e = Expression::MakeTuple(e->line_num, new_args);
auto tuple_t = Value::MakeTupleVal(arg_types);
auto tuple_e = Expression::MakeTupleLiteral(e->line_num, new_args);
auto tuple_t = Value::MakeTupleValue(arg_types);
return TCResult(tuple_e, tuple_t, new_types);
}
case ExpressionKind::GetField: {
auto res = TypeCheckExp(e->GetFieldAccess().aggregate, types, values,
nullptr, TCContext::ValueContext);
case ExpressionKind::FieldAccessExpression: {
auto res = TypeCheckExp(e->GetFieldAccessExpression().aggregate, types,
values, nullptr, TCContext::ValueContext);
auto t = res.type;
switch (t->tag) {
case ValKind::StructTV:
case ValKind::StructType:
// Search for a field
for (auto& field : *t->GetStructType().fields) {
if (e->GetFieldAccess().field == field.first) {
const Expression* new_e = Expression::MakeGetField(
e->line_num, res.exp, e->GetFieldAccess().field);
if (e->GetFieldAccessExpression().field == field.first) {
const Expression* new_e = Expression::MakeFieldAccessExpression(
e->line_num, res.exp, e->GetFieldAccessExpression().field);
return TCResult(new_e, field.second, res.types);
}
}
// Search for a method
for (auto& method : *t->GetStructType().methods) {
if (e->GetFieldAccess().field == method.first) {
const Expression* new_e = Expression::MakeGetField(
e->line_num, res.exp, e->GetFieldAccess().field);
if (e->GetFieldAccessExpression().field == method.first) {
const Expression* new_e = Expression::MakeFieldAccessExpression(
e->line_num, res.exp, e->GetFieldAccessExpression().field);
return TCResult(new_e, method.second, res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
<< *t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccess().field << std::endl;
<< e->GetFieldAccessExpression().field << std::endl;
exit(-1);
case ValKind::TupleV:
for (const TupleElement& field : *t->GetTuple().elements) {
if (e->GetFieldAccess().field == field.name) {
auto new_e = Expression::MakeGetField(e->line_num, res.exp,
e->GetFieldAccess().field);
case ValKind::TupleValue:
for (const TupleElement& field : *t->GetTupleValue().elements) {
if (e->GetFieldAccessExpression().field == field.name) {
auto new_e = Expression::MakeFieldAccessExpression(
e->line_num, res.exp, e->GetFieldAccessExpression().field);
return TCResult(new_e,
state->heap.Read(field.address, e->line_num),
res.types);
@@ -272,22 +274,22 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
std::cerr << e->line_num << ": compilation error, struct "
<< *t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccess().field << std::endl;
<< e->GetFieldAccessExpression().field << std::endl;
exit(-1);
case ValKind::ChoiceTV:
case ValKind::ChoiceType:
for (auto vt = t->GetChoiceType().alternatives->begin();
vt != t->GetChoiceType().alternatives->end(); ++vt) {
if (e->GetFieldAccess().field == vt->first) {
const Expression* new_e = Expression::MakeGetField(
e->line_num, res.exp, e->GetFieldAccess().field);
auto fun_ty = Value::MakeFunTypeVal(vt->second, t);
if (e->GetFieldAccessExpression().field == vt->first) {
const Expression* new_e = Expression::MakeFieldAccessExpression(
e->line_num, res.exp, e->GetFieldAccessExpression().field);
auto fun_ty = Value::MakeFunctionType(vt->second, t);
return TCResult(new_e, fun_ty, res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
<< *t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccess().field << std::endl;
<< e->GetFieldAccessExpression().field << std::endl;
exit(-1);
default:
@@ -299,91 +301,91 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
exit(-1);
}
}
case ExpressionKind::Variable: {
std::optional<const Value*> type = types.Get(e->GetVariable().name);
case ExpressionKind::IdentifierExpression: {
std::optional<const Value*> type =
types.Get(e->GetIdentifierExpression().name);
if (type) {
return TCResult(e, *type, types);
} else {
std::cerr << e->line_num << ": could not find `"
<< e->GetVariable().name << "`" << std::endl;
<< e->GetIdentifierExpression().name << "`" << std::endl;
exit(-1);
}
}
case ExpressionKind::Integer:
return TCResult(e, Value::MakeIntTypeVal(), types);
case ExpressionKind::Boolean:
return TCResult(e, Value::MakeBoolTypeVal(), types);
case ExpressionKind::PrimitiveOp: {
case ExpressionKind::IntLiteral:
return TCResult(e, Value::MakeIntType(), types);
case ExpressionKind::BoolLiteral:
return TCResult(e, Value::MakeBoolType(), types);
case ExpressionKind::PrimitiveOperatorExpression: {
std::vector<const Expression*> es;
std::vector<const Value*> ts;
auto new_types = types;
for (const Expression* argument : e->GetPrimitiveOperator().arguments) {
for (const Expression* argument :
e->GetPrimitiveOperatorExpression().arguments) {
auto res = TypeCheckExp(argument, types, values, nullptr,
TCContext::ValueContext);
new_types = res.types;
es.push_back(res.exp);
ts.push_back(res.type);
}
auto new_e =
Expression::MakeOp(e->line_num, e->GetPrimitiveOperator().op, es);
switch (e->GetPrimitiveOperator().op) {
auto new_e = Expression::MakePrimitiveOperatorExpression(
e->line_num, e->GetPrimitiveOperatorExpression().op, es);
switch (e->GetPrimitiveOperatorExpression().op) {
case Operator::Neg:
ExpectType(e->line_num, "negation", Value::MakeIntTypeVal(), ts[0]);
return TCResult(new_e, Value::MakeIntTypeVal(), new_types);
ExpectType(e->line_num, "negation", Value::MakeIntType(), ts[0]);
return TCResult(new_e, Value::MakeIntType(), new_types);
case Operator::Add:
ExpectType(e->line_num, "addition(1)", Value::MakeIntTypeVal(),
ts[0]);
ExpectType(e->line_num, "addition(2)", Value::MakeIntTypeVal(),
ts[1]);
return TCResult(new_e, Value::MakeIntTypeVal(), new_types);
ExpectType(e->line_num, "addition(1)", Value::MakeIntType(), ts[0]);
ExpectType(e->line_num, "addition(2)", Value::MakeIntType(), ts[1]);
return TCResult(new_e, Value::MakeIntType(), new_types);
case Operator::Sub:
ExpectType(e->line_num, "subtraction(1)", Value::MakeIntTypeVal(),
ExpectType(e->line_num, "subtraction(1)", Value::MakeIntType(),
ts[0]);
ExpectType(e->line_num, "subtraction(2)", Value::MakeIntTypeVal(),
ExpectType(e->line_num, "subtraction(2)", Value::MakeIntType(),
ts[1]);
return TCResult(new_e, Value::MakeIntTypeVal(), new_types);
return TCResult(new_e, Value::MakeIntType(), new_types);
case Operator::Mul:
ExpectType(e->line_num, "multiplication(1)", Value::MakeIntTypeVal(),
ExpectType(e->line_num, "multiplication(1)", Value::MakeIntType(),
ts[0]);
ExpectType(e->line_num, "multiplication(2)", Value::MakeIntTypeVal(),
ExpectType(e->line_num, "multiplication(2)", Value::MakeIntType(),
ts[1]);
return TCResult(new_e, Value::MakeIntTypeVal(), new_types);
return TCResult(new_e, Value::MakeIntType(), new_types);
case Operator::And:
ExpectType(e->line_num, "&&(1)", Value::MakeBoolTypeVal(), ts[0]);
ExpectType(e->line_num, "&&(2)", Value::MakeBoolTypeVal(), ts[1]);
return TCResult(new_e, Value::MakeBoolTypeVal(), new_types);
ExpectType(e->line_num, "&&(1)", Value::MakeBoolType(), ts[0]);
ExpectType(e->line_num, "&&(2)", Value::MakeBoolType(), ts[1]);
return TCResult(new_e, Value::MakeBoolType(), new_types);
case Operator::Or:
ExpectType(e->line_num, "||(1)", Value::MakeBoolTypeVal(), ts[0]);
ExpectType(e->line_num, "||(2)", Value::MakeBoolTypeVal(), ts[1]);
return TCResult(new_e, Value::MakeBoolTypeVal(), new_types);
ExpectType(e->line_num, "||(1)", Value::MakeBoolType(), ts[0]);
ExpectType(e->line_num, "||(2)", Value::MakeBoolType(), ts[1]);
return TCResult(new_e, Value::MakeBoolType(), new_types);
case Operator::Not:
ExpectType(e->line_num, "!", Value::MakeBoolTypeVal(), ts[0]);
return TCResult(new_e, Value::MakeBoolTypeVal(), new_types);
ExpectType(e->line_num, "!", Value::MakeBoolType(), ts[0]);
return TCResult(new_e, Value::MakeBoolType(), new_types);
case Operator::Eq:
ExpectType(e->line_num, "==", ts[0], ts[1]);
return TCResult(new_e, Value::MakeBoolTypeVal(), new_types);
return TCResult(new_e, Value::MakeBoolType(), new_types);
case Operator::Deref:
ExpectPointerType(e->line_num, "*", ts[0]);
return TCResult(new_e, ts[0]->GetPointerType().type, new_types);
case Operator::Ptr:
ExpectType(e->line_num, "*", Value::MakeTypeTypeVal(), ts[0]);
return TCResult(new_e, Value::MakeTypeTypeVal(), new_types);
ExpectType(e->line_num, "*", Value::MakeTypeType(), ts[0]);
return TCResult(new_e, Value::MakeTypeType(), new_types);
}
break;
}
case ExpressionKind::Call: {
auto fun_res = TypeCheckExp(e->GetCall().function, types, values, nullptr,
TCContext::ValueContext);
case ExpressionKind::CallExpression: {
auto fun_res = TypeCheckExp(e->GetCallExpression().function, types,
values, nullptr, TCContext::ValueContext);
switch (fun_res.type->tag) {
case ValKind::FunctionTV: {
case ValKind::FunctionType: {
auto fun_t = fun_res.type;
auto arg_res =
TypeCheckExp(e->GetCall().argument, fun_res.types, values,
fun_t->GetFunctionType().param, context);
TypeCheckExp(e->GetCallExpression().argument, fun_res.types,
values, fun_t->GetFunctionType().param, context);
ExpectType(e->line_num, "call", fun_t->GetFunctionType().param,
arg_res.type);
auto new_e =
Expression::MakeCall(e->line_num, fun_res.exp, arg_res.exp);
auto new_e = Expression::MakeCallExpression(e->line_num, fun_res.exp,
arg_res.exp);
return TCResult(new_e, fun_t->GetFunctionType().ret, arg_res.types);
}
default: {
@@ -397,40 +399,40 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
}
break;
}
case ExpressionKind::FunctionT: {
case ExpressionKind::FunctionTypeLiteral: {
switch (context) {
case TCContext::ValueContext:
case TCContext::TypeContext: {
auto pt = InterpExp(values, e->GetFunctionType().parameter);
auto rt = InterpExp(values, e->GetFunctionType().return_type);
auto new_e =
Expression::MakeFunType(e->line_num, ReifyType(pt, e->line_num),
ReifyType(rt, e->line_num));
return TCResult(new_e, Value::MakeTypeTypeVal(), types);
auto pt = InterpExp(values, e->GetFunctionTypeLiteral().parameter);
auto rt = InterpExp(values, e->GetFunctionTypeLiteral().return_type);
auto new_e = Expression::MakeFunctionTypeLiteral(
e->line_num, ReifyType(pt, e->line_num),
ReifyType(rt, e->line_num));
return TCResult(new_e, Value::MakeTypeType(), types);
}
case TCContext::PatternContext: {
auto param_res = TypeCheckExp(e->GetFunctionType().parameter, types,
values, nullptr, context);
auto param_res = TypeCheckExp(e->GetFunctionTypeLiteral().parameter,
types, values, nullptr, context);
auto ret_res =
TypeCheckExp(e->GetFunctionType().return_type, param_res.types,
values, nullptr, context);
auto new_e = Expression::MakeFunType(
TypeCheckExp(e->GetFunctionTypeLiteral().return_type,
param_res.types, values, nullptr, context);
auto new_e = Expression::MakeFunctionTypeLiteral(
e->line_num, ReifyType(param_res.type, e->line_num),
ReifyType(ret_res.type, e->line_num));
return TCResult(new_e, Value::MakeTypeTypeVal(), ret_res.types);
return TCResult(new_e, Value::MakeTypeType(), ret_res.types);
}
}
}
case ExpressionKind::IntT:
return TCResult(e, Value::MakeTypeTypeVal(), types);
case ExpressionKind::BoolT:
return TCResult(e, Value::MakeTypeTypeVal(), types);
case ExpressionKind::TypeT:
return TCResult(e, Value::MakeTypeTypeVal(), types);
case ExpressionKind::AutoT:
return TCResult(e, Value::MakeTypeTypeVal(), types);
case ExpressionKind::ContinuationT:
return TCResult(e, Value::MakeTypeTypeVal(), types);
case ExpressionKind::IntTypeLiteral:
return TCResult(e, Value::MakeTypeType(), types);
case ExpressionKind::BoolTypeLiteral:
return TCResult(e, Value::MakeTypeType(), types);
case ExpressionKind::TypeTypeLiteral:
return TCResult(e, Value::MakeTypeType(), types);
case ExpressionKind::AutoTypeLiteral:
return TCResult(e, Value::MakeTypeType(), types);
case ExpressionKind::ContinuationTypeLiteral:
return TCResult(e, Value::MakeTypeType(), types);
}
}
@@ -474,7 +476,7 @@ auto TypeCheckStmt(const Statement* s, TypeEnv types, Env values,
case StatementKind::While: {
auto cnd_res = TypeCheckExp(s->GetWhile().cond, types, values, nullptr,
TCContext::ValueContext);
ExpectType(s->line_num, "condition of `while`", Value::MakeBoolTypeVal(),
ExpectType(s->line_num, "condition of `while`", Value::MakeBoolType(),
cnd_res.type);
auto body_res =
TypeCheckStmt(s->GetWhile().body, types, values, ret_type);
@@ -532,7 +534,7 @@ auto TypeCheckStmt(const Statement* s, TypeEnv types, Env values,
case StatementKind::If: {
auto cnd_res = TypeCheckExp(s->GetIf().cond, types, values, nullptr,
TCContext::ValueContext);
ExpectType(s->line_num, "condition of `if`", Value::MakeBoolTypeVal(),
ExpectType(s->line_num, "condition of `if`", Value::MakeBoolType(),
cnd_res.type);
auto thn_res =
TypeCheckStmt(s->GetIf().then_stmt, types, values, ret_type);
@@ -545,7 +547,7 @@ auto TypeCheckStmt(const Statement* s, TypeEnv types, Env values,
case StatementKind::Return: {
auto res = TypeCheckExp(s->GetReturn(), types, values, nullptr,
TCContext::ValueContext);
if (ret_type->tag == ValKind::AutoTV) {
if (ret_type->tag == ValKind::AutoType) {
// The following infers the return type from the first 'return'
// statement. This will get more difficult with subtyping, when we
// should infer the least-upper bound of all the 'return' statements.
@@ -562,7 +564,7 @@ auto TypeCheckStmt(const Statement* s, TypeEnv types, Env values,
s->line_num, *s->GetContinuation().continuation_variable,
body_result.stmt);
types.Set(*s->GetContinuation().continuation_variable,
Value::MakeContinuationTypeVal());
Value::MakeContinuationType());
return TCStatement(new_continuation, types);
}
case StatementKind::Run: {
@@ -570,7 +572,7 @@ auto TypeCheckStmt(const Statement* s, TypeEnv types, Env values,
TypeCheckExp(s->GetRun().argument, types, values, nullptr,
TCContext::ValueContext);
ExpectType(s->line_num, "argument of `run`",
Value::MakeContinuationTypeVal(), argument_result.type);
Value::MakeContinuationType(), argument_result.type);
const Statement* new_run =
Statement::MakeRun(s->line_num, argument_result.exp);
return TCStatement(new_run, types);
@@ -587,7 +589,7 @@ auto CheckOrEnsureReturn(const Statement* stmt, bool void_return, int line_num)
if (!stmt) {
if (void_return) {
return Statement::MakeReturn(line_num,
Expression::MakeTuple(line_num, {}));
Expression::MakeTupleLiteral(line_num, {}));
} else {
std::cerr
<< "control-flow reaches end of non-void function without a return"
@@ -643,8 +645,8 @@ auto CheckOrEnsureReturn(const Statement* stmt, bool void_return, int line_num)
if (void_return) {
return Statement::MakeSeq(
stmt->line_num, stmt,
Statement::MakeReturn(stmt->line_num,
Expression::MakeTuple(stmt->line_num, {})));
Statement::MakeReturn(stmt->line_num, Expression::MakeTupleLiteral(
stmt->line_num, {})));
} else {
std::cerr
<< stmt->line_num
@@ -662,7 +664,7 @@ auto TypeCheckFunDef(const FunctionDefinition* f, TypeEnv types, Env values)
TCContext::PatternContext);
auto return_type = InterpExp(values, f->return_type);
if (f->name == "main") {
ExpectType(f->line_num, "return type of `main`", Value::MakeIntTypeVal(),
ExpectType(f->line_num, "return type of `main`", Value::MakeIntType(),
return_type);
// TODO: Check that main doesn't have any parameters.
}
@@ -679,11 +681,11 @@ auto TypeOfFunDef(TypeEnv types, Env values, const FunctionDefinition* fun_def)
auto param_res = TypeCheckExp(fun_def->param_pattern, types, values, nullptr,
TCContext::PatternContext);
auto ret = InterpExp(values, fun_def->return_type);
if (ret->tag == ValKind::AutoTV) {
if (ret->tag == ValKind::AutoType) {
auto f = TypeCheckFunDef(fun_def, types, values);
ret = InterpExp(values, f->return_type);
}
return Value::MakeFunTypeVal(param_res.type, ret);
return Value::MakeFunctionType(param_res.type, ret);
}
auto TypeOfStructDef(const StructDefinition* sd, TypeEnv /*types*/, Env ct_top)
@@ -696,7 +698,7 @@ auto TypeOfStructDef(const StructDefinition* sd, TypeEnv /*types*/, Env ct_top)
fields->push_back(std::make_pair(*(*m)->u.field.name, t));
}
}
return Value::MakeStructTypeVal(*sd->name, fields, methods);
return Value::MakeStructType(*sd->name, fields, methods);
}
auto FunctionDeclaration::Name() const -> std::string {
@@ -779,7 +781,7 @@ auto StructDeclaration::TopLevel(TypeCheckContext& tops) const -> void {
field_types->push_back({.name = field_name,
.address = state->heap.AllocateValue(field_value)});
}
auto fun_ty = Value::MakeFunTypeVal(Value::MakeTupleVal(field_types), st);
auto fun_ty = Value::MakeFunctionType(Value::MakeTupleValue(field_types), st);
tops.types.Set(Name(), fun_ty);
}
@@ -789,7 +791,7 @@ auto ChoiceDeclaration::TopLevel(TypeCheckContext& tops) const -> void {
auto t = InterpExp(tops.values, signature);
alts->push_back(std::make_pair(name, t));
}
auto ct = Value::MakeChoiceTypeVal(name, alts);
auto ct = Value::MakeChoiceType(name, alts);
Address a = state->heap.AllocateValue(ct);
tops.values.Set(Name(), a); // Is this obsolete?
tops.types.Set(Name(), ct);
executable_semantics/interpreter/value.cpp
+150 -145
View File
@@ -12,43 +12,43 @@
namespace Carbon {
int Value::GetInteger() const {
CHECK(tag == ValKind::IntV);
int Value::GetIntValue() const {
CHECK(tag == ValKind::IntValue);
return u.integer;
}
bool Value::GetBoolean() const {
CHECK(tag == ValKind::BoolV);
bool Value::GetBoolValue() const {
CHECK(tag == ValKind::BoolValue);
return u.boolean;
}
Function Value::GetFunction() const {
CHECK(tag == ValKind::FunV);
FunctionValue Value::GetFunctionValue() const {
CHECK(tag == ValKind::FunctionValue);
return u.fun;
}
StructConstructor Value::GetStruct() const {
CHECK(tag == ValKind::StructV);
StructValue Value::GetStructValue() const {
CHECK(tag == ValKind::StructValue);
return u.struct_val;
}
AlternativeConstructor Value::GetAlternativeConstructor() const {
CHECK(tag == ValKind::AltConsV);
AlternativeConstructorValue Value::GetAlternativeConstructorValue() const {
CHECK(tag == ValKind::AlternativeConstructorValue);
return u.alt_cons;
}
Alternative Value::GetAlternative() const {
CHECK(tag == ValKind::AltV);
AlternativeValue Value::GetAlternativeValue() const {
CHECK(tag == ValKind::AlternativeValue);
return u.alt;
}
TupleValue Value::GetTuple() const {
CHECK(tag == ValKind::TupleV);
TupleValue Value::GetTupleValue() const {
CHECK(tag == ValKind::TupleValue);
return u.tuple;
}
Address Value::GetPointer() const {
CHECK(tag == ValKind::PtrV);
Address Value::GetPointerValue() const {
CHECK(tag == ValKind::PointerValue);
return u.ptr;
}
@@ -57,33 +57,33 @@ std::string* Value::GetVariableType() const {
return u.var_type;
}
VariablePatternValue Value::GetVariablePattern() const {
CHECK(tag == ValKind::VarPatV);
PatternVariableValue Value::GetPatternVariableValue() const {
CHECK(tag == ValKind::PatternVariableValue);
return u.var_pat;
}
FunctionTypeValue Value::GetFunctionType() const {
CHECK(tag == ValKind::FunctionTV);
FunctionType Value::GetFunctionType() const {
CHECK(tag == ValKind::FunctionType);
return u.fun_type;
}
PointerType Value::GetPointerType() const {
CHECK(tag == ValKind::PointerTV);
CHECK(tag == ValKind::PointerType);
return u.ptr_type;
}
StructType Value::GetStructType() const {
CHECK(tag == ValKind::StructTV);
CHECK(tag == ValKind::StructType);
return u.struct_type;
}
ChoiceType Value::GetChoiceType() const {
CHECK(tag == ValKind::ChoiceTV);
CHECK(tag == ValKind::ChoiceType);
return u.choice_type;
}
ContinuationValue Value::GetContinuation() const {
CHECK(tag == ValKind::ContinuationV);
ContinuationValue Value::GetContinuationValue() const {
CHECK(tag == ValKind::ContinuationValue);
return u.continuation;
}
@@ -116,8 +116,8 @@ auto FieldsEqual(VarValues* ts1, VarValues* ts2) -> bool {
auto FindTupleField(const std::string& name, const Value* tuple)
-> std::optional<Address> {
CHECK(tuple->tag == ValKind::TupleV);
for (const TupleElement& element : *tuple->GetTuple().elements) {
CHECK(tuple->tag == ValKind::TupleValue);
for (const TupleElement& element : *tuple->GetTupleValue().elements) {
if (element.name == name) {
return element.address;
}
@@ -125,67 +125,69 @@ auto FindTupleField(const std::string& name, const Value* tuple)
return std::nullopt;
}
auto Value::MakeIntVal(int i) -> const Value* {
auto Value::MakeIntValue(int i) -> const Value* {
auto* v = new Value();
v->tag = ValKind::IntV;
v->tag = ValKind::IntValue;
v->u.integer = i;
return v;
}
auto Value::MakeBoolVal(bool b) -> const Value* {
auto Value::MakeBoolValue(bool b) -> const Value* {
auto* v = new Value();
v->tag = ValKind::BoolV;
v->tag = ValKind::BoolValue;
v->u.boolean = b;
return v;
}
auto Value::MakeFunVal(std::string name, const Value* param,
const Statement* body) -> const Value* {
auto Value::MakeFunctionValue(std::string name, const Value* param,
const Statement* body) -> const Value* {
auto* v = new Value();
v->tag = ValKind::FunV;
v->tag = ValKind::FunctionValue;
v->u.fun.name = new std::string(std::move(name));
v->u.fun.param = param;
v->u.fun.body = body;
return v;
}
auto Value::MakePtrVal(Address addr) -> const Value* {
auto Value::MakePointerValue(Address addr) -> const Value* {
auto* v = new Value();
v->tag = ValKind::PtrV;
v->tag = ValKind::PointerValue;
v->u.ptr = addr;
return v;
}
auto Value::MakeStructVal(const Value* type, const Value* inits)
auto Value::MakeStructValue(const Value* type, const Value* inits)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::StructV;
v->tag = ValKind::StructValue;
v->u.struct_val.type = type;
v->u.struct_val.inits = inits;
return v;
}
auto Value::MakeTupleVal(std::vector<TupleElement>* elements) -> const Value* {
auto Value::MakeTupleValue(std::vector<TupleElement>* elements)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::TupleV;
v->tag = ValKind::TupleValue;
v->u.tuple.elements = elements;
return v;
}
auto Value::MakeAltVal(std::string alt_name, std::string choice_name,
Address argument) -> const Value* {
auto Value::MakeAlternativeValue(std::string alt_name, std::string choice_name,
Address argument) -> const Value* {
auto* v = new Value();
v->tag = ValKind::AltV;
v->tag = ValKind::AlternativeValue;
v->u.alt.alt_name = new std::string(std::move(alt_name));
v->u.alt.choice_name = new std::string(std::move(choice_name));
v->u.alt.argument = argument;
return v;
}
auto Value::MakeAltCons(std::string alt_name, std::string choice_name)
auto Value::MakeAlternativeConstructorValue(std::string alt_name,
std::string choice_name)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::AltConsV;
v->tag = ValKind::AlternativeConstructorValue;
v->u.alt.alt_name = new std::string(std::move(alt_name));
v->u.alt.choice_name = new std::string(std::move(choice_name));
return v;
@@ -193,16 +195,17 @@ auto Value::MakeAltCons(std::string alt_name, std::string choice_name)
// Return a first-class continuation represented a fragment
// of the stack.
auto Value::MakeContinuation(std::vector<Frame*> stack) -> Value* {
auto Value::MakeContinuationValue(std::vector<Frame*> stack) -> Value* {
auto* v = new Value();
v->tag = ValKind::ContinuationV;
v->tag = ValKind::ContinuationValue;
v->u.continuation.stack = new std::vector<Frame*>(stack);
return v;
}
auto Value::MakeVarPatVal(std::string name, const Value* type) -> const Value* {
auto Value::MakePatternVariableValue(std::string name, const Value* type)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::VarPatV;
v->tag = ValKind::PatternVariableValue;
v->u.var_pat.name = new std::string(std::move(name));
v->u.var_pat.type = type;
return v;
@@ -215,57 +218,57 @@ auto Value::MakeVarTypeVal(std::string name) -> const Value* {
return v;
}
auto Value::MakeIntTypeVal() -> const Value* {
auto Value::MakeIntType() -> const Value* {
auto* v = new Value();
v->tag = ValKind::IntTV;
v->tag = ValKind::IntType;
return v;
}
auto Value::MakeBoolTypeVal() -> const Value* {
auto Value::MakeBoolType() -> const Value* {
auto* v = new Value();
v->tag = ValKind::BoolTV;
v->tag = ValKind::BoolType;
return v;
}
auto Value::MakeTypeTypeVal() -> const Value* {
auto Value::MakeTypeType() -> const Value* {
auto* v = new Value();
v->tag = ValKind::TypeTV;
v->tag = ValKind::TypeType;
return v;
}
// Return a Continuation type.
auto Value::MakeContinuationTypeVal() -> const Value* {
auto Value::MakeContinuationType() -> const Value* {
auto* v = new Value();
v->tag = ValKind::ContinuationTV;
v->tag = ValKind::ContinuationType;
return v;
}
auto Value::MakeAutoTypeVal() -> const Value* {
auto Value::MakeAutoType() -> const Value* {
auto* v = new Value();
v->tag = ValKind::AutoTV;
v->tag = ValKind::AutoType;
return v;
}
auto Value::MakeFunTypeVal(const Value* param, const Value* ret)
auto Value::MakeFunctionType(const Value* param, const Value* ret)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::FunctionTV;
v->tag = ValKind::FunctionType;
v->u.fun_type.param = param;
v->u.fun_type.ret = ret;
return v;
}
auto Value::MakePtrTypeVal(const Value* type) -> const Value* {
auto Value::MakePointerType(const Value* type) -> const Value* {
auto* v = new Value();
v->tag = ValKind::PointerTV;
v->tag = ValKind::PointerType;
v->u.ptr_type.type = type;
return v;
}
auto Value::MakeStructTypeVal(std::string name, VarValues* fields,
VarValues* methods) -> const Value* {
auto Value::MakeStructType(std::string name, VarValues* fields,
VarValues* methods) -> const Value* {
auto* v = new Value();
v->tag = ValKind::StructTV;
v->tag = ValKind::StructType;
v->u.struct_type.name = new std::string(std::move(name));
v->u.struct_type.fields = fields;
v->u.struct_type.methods = methods;
@@ -274,16 +277,16 @@ auto Value::MakeStructTypeVal(std::string name, VarValues* fields,
auto Value::MakeUnitTypeVal() -> const Value* {
auto* v = new Value();
v->tag = ValKind::TupleV;
v->tag = ValKind::TupleValue;
v->u.tuple.elements = new std::vector<TupleElement>();
return v;
}
auto Value::MakeChoiceTypeVal(
auto Value::MakeChoiceType(
std::string name, std::list<std::pair<std::string, const Value*>>* alts)
-> const Value* {
auto* v = new Value();
v->tag = ValKind::ChoiceTV;
v->tag = ValKind::ChoiceType;
// Transitional leak: when we get rid of all pointers, this will disappear.
v->u.choice_type.name = new std::string(name);
v->u.choice_type.alternatives = alts;
@@ -292,31 +295,31 @@ auto Value::MakeChoiceTypeVal(
auto PrintValue(const Value* val, std::ostream& out) -> void {
switch (val->tag) {
case ValKind::AltConsV: {
out << *val->GetAlternativeConstructor().choice_name << "."
<< *val->GetAlternativeConstructor().alt_name;
case ValKind::AlternativeConstructorValue: {
out << *val->GetAlternativeConstructorValue().choice_name << "."
<< *val->GetAlternativeConstructorValue().alt_name;
break;
}
case ValKind::VarPatV: {
PrintValue(val->GetVariablePattern().type, out);
out << ": " << *val->GetVariablePattern().name;
case ValKind::PatternVariableValue: {
PrintValue(val->GetPatternVariableValue().type, out);
out << ": " << *val->GetPatternVariableValue().name;
break;
}
case ValKind::AltV: {
out << "alt " << *val->GetAlternative().choice_name << "."
<< *val->GetAlternative().alt_name << " ";
state->heap.PrintAddress(val->GetAlternative().argument, out);
case ValKind::AlternativeValue: {
out << "alt " << *val->GetAlternativeValue().choice_name << "."
<< *val->GetAlternativeValue().alt_name << " ";
state->heap.PrintAddress(val->GetAlternativeValue().argument, out);
break;
}
case ValKind::StructV: {
out << *val->GetStruct().type->GetStructType().name;
PrintValue(val->GetStruct().inits, out);
case ValKind::StructValue: {
out << *val->GetStructValue().type->GetStructType().name;
PrintValue(val->GetStructValue().inits, out);
break;
}
case ValKind::TupleV: {
case ValKind::TupleValue: {
out << "(";
bool add_commas = false;
for (const TupleElement& element : *val->GetTuple().elements) {
for (const TupleElement& element : *val->GetTupleValue().elements) {
if (add_commas) {
out << ", ";
} else {
@@ -329,38 +332,38 @@ auto PrintValue(const Value* val, std::ostream& out) -> void {
out << ")";
break;
}
case ValKind::IntV:
out << val->GetInteger();
case ValKind::IntValue:
out << val->GetIntValue();
break;
case ValKind::BoolV:
out << std::boolalpha << val->GetBoolean();
case ValKind::BoolValue:
out << std::boolalpha << val->GetBoolValue();
break;
case ValKind::FunV:
out << "fun<" << *val->GetFunction().name << ">";
case ValKind::FunctionValue:
out << "fun<" << *val->GetFunctionValue().name << ">";
break;
case ValKind::PtrV:
out << "ptr<" << val->GetPointer() << ">";
case ValKind::PointerValue:
out << "ptr<" << val->GetPointerValue() << ">";
break;
case ValKind::BoolTV:
case ValKind::BoolType:
out << "Bool";
break;
case ValKind::IntTV:
case ValKind::IntType:
out << "Int";
break;
case ValKind::TypeTV:
case ValKind::TypeType:
out << "Type";
break;
case ValKind::AutoTV:
case ValKind::AutoType:
out << "auto";
break;
case ValKind::ContinuationTV:
case ValKind::ContinuationType:
out << "Continuation";
break;
case ValKind::PointerTV:
case ValKind::PointerType:
PrintValue(val->GetPointerType().type, out);
out << "*";
break;
case ValKind::FunctionTV:
case ValKind::FunctionType:
out << "fn ";
PrintValue(val->GetFunctionType().param, out);
out << " -> ";
@@ -369,15 +372,15 @@ auto PrintValue(const Value* val, std::ostream& out) -> void {
case ValKind::VarTV:
out << *val->GetVariableType();
break;
case ValKind::StructTV:
case ValKind::StructType:
out << "struct " << *val->GetStructType().name;
break;
case ValKind::ChoiceTV:
case ValKind::ChoiceType:
out << "choice " << *val->GetChoiceType().name;
break;
case ValKind::ContinuationV:
case ValKind::ContinuationValue:
out << "continuation[[";
for (Frame* frame : *val->GetContinuation().stack) {
for (Frame* frame : *val->GetContinuationValue().stack) {
PrintFrame(frame, out);
out << " :: ";
}
@@ -393,37 +396,39 @@ auto TypeEqual(const Value* t1, const Value* t2) -> bool {
switch (t1->tag) {
case ValKind::VarTV:
return *t1->GetVariableType() == *t2->GetVariableType();
case ValKind::PointerTV:
case ValKind::PointerType:
return TypeEqual(t1->GetPointerType().type, t2->GetPointerType().type);
case ValKind::FunctionTV:
case ValKind::FunctionType:
return TypeEqual(t1->GetFunctionType().param,
t2->GetFunctionType().param) &&
TypeEqual(t1->GetFunctionType().ret, t2->GetFunctionType().ret);
case ValKind::StructTV:
case ValKind::StructType:
return *t1->GetStructType().name == *t2->GetStructType().name;
case ValKind::ChoiceTV:
case ValKind::ChoiceType:
return *t1->GetChoiceType().name == *t2->GetChoiceType().name;
case ValKind::TupleV: {
if (t1->GetTuple().elements->size() != t2->GetTuple().elements->size()) {
case ValKind::TupleValue: {
if (t1->GetTupleValue().elements->size() !=
t2->GetTupleValue().elements->size()) {
return false;
}
for (size_t i = 0; i < t1->GetTuple().elements->size(); ++i) {
if ((*t1->GetTuple().elements)[i].name !=
(*t2->GetTuple().elements)[i].name) {
for (size_t i = 0; i < t1->GetTupleValue().elements->size(); ++i) {
if ((*t1->GetTupleValue().elements)[i].name !=
(*t2->GetTupleValue().elements)[i].name) {
return false;
}
if (!TypeEqual(
state->heap.Read((*t1->GetTuple().elements)[i].address, 0),
state->heap.Read((*t2->GetTuple().elements)[i].address, 0))) {
state->heap.Read((*t1->GetTupleValue().elements)[i].address, 0),
state->heap.Read((*t2->GetTupleValue().elements)[i].address,
0))) {
return false;
}
}
return true;
}
case ValKind::IntTV:
case ValKind::BoolTV:
case ValKind::ContinuationTV:
case ValKind::TypeTV:
case ValKind::IntType:
case ValKind::BoolType:
case ValKind::ContinuationType:
case ValKind::TypeType:
return true;
default:
std::cerr << "TypeEqual used to compare non-type values" << std::endl;
@@ -465,34 +470,34 @@ auto ValueEqual(const Value* v1, const Value* v2, int line_num) -> bool {
return false;
}
switch (v1->tag) {
case ValKind::IntV:
return v1->GetInteger() == v2->GetInteger();
case ValKind::BoolV:
return v1->GetBoolean() == v2->GetBoolean();
case ValKind::PtrV:
return v1->GetPointer() == v2->GetPointer();
case ValKind::FunV:
return v1->GetFunction().body == v2->GetFunction().body;
case ValKind::TupleV:
return FieldsValueEqual(v1->GetTuple().elements, v2->GetTuple().elements,
line_num);
case ValKind::IntValue:
return v1->GetIntValue() == v2->GetIntValue();
case ValKind::BoolValue:
return v1->GetBoolValue() == v2->GetBoolValue();
case ValKind::PointerValue:
return v1->GetPointerValue() == v2->GetPointerValue();
case ValKind::FunctionValue:
return v1->GetFunctionValue().body == v2->GetFunctionValue().body;
case ValKind::TupleValue:
return FieldsValueEqual(v1->GetTupleValue().elements,
v2->GetTupleValue().elements, line_num);
default:
case ValKind::VarTV:
case ValKind::IntTV:
case ValKind::BoolTV:
case ValKind::TypeTV:
case ValKind::FunctionTV:
case ValKind::PointerTV:
case ValKind::AutoTV:
case ValKind::StructTV:
case ValKind::ChoiceTV:
case ValKind::ContinuationTV:
case ValKind::IntType:
case ValKind::BoolType:
case ValKind::TypeType:
case ValKind::FunctionType:
case ValKind::PointerType:
case ValKind::AutoType:
case ValKind::StructType:
case ValKind::ChoiceType:
case ValKind::ContinuationType:
return TypeEqual(v1, v2);
case ValKind::StructV:
case ValKind::AltV:
case ValKind::VarPatV:
case ValKind::AltConsV:
case ValKind::ContinuationV:
case ValKind::StructValue:
case ValKind::AlternativeValue:
case ValKind::PatternVariableValue:
case ValKind::AlternativeConstructorValue:
case ValKind::ContinuationValue:
std::cerr << "ValueEqual does not support this kind of value."
<< std::endl;
exit(-1);
@@ -501,8 +506,8 @@ auto ValueEqual(const Value* v1, const Value* v2, int line_num) -> bool {
auto ToInteger(const Value* v) -> int {
switch (v->tag) {
case ValKind::IntV:
return v->GetInteger();
case ValKind::IntValue:
return v->GetIntValue();
default:
std::cerr << "expected an integer, not ";
PrintValue(v, std::cerr);
executable_semantics/interpreter/value.h
+66 -65
View File
@@ -37,47 +37,47 @@ struct TupleElement {
};
enum class ValKind {
IntV,
FunV,
PtrV,
BoolV,
StructV,
AltV,
TupleV,
IntValue,
FunctionValue,
PointerValue,
BoolValue,
StructValue,
AlternativeValue,
TupleValue,
VarTV,
IntTV,
BoolTV,
TypeTV,
FunctionTV,
PointerTV,
AutoTV,
StructTV,
ChoiceTV,
ContinuationTV, // The type of a continuation.
VarPatV,
AltConsV,
ContinuationV // A first-class continuation value.
IntType,
BoolType,
TypeType,
FunctionType,
PointerType,
AutoType,
StructType,
ChoiceType,
ContinuationType, // The type of a continuation.
PatternVariableValue,
AlternativeConstructorValue,
ContinuationValue // A first-class continuation value.
};
struct Frame; // used by continuation
struct Function {
struct FunctionValue {
std::string* name;
const Value* param;
const Statement* body;
};
struct StructConstructor {
struct StructValue {
const Value* type;
const Value* inits;
};
struct AlternativeConstructor {
struct AlternativeConstructorValue {
std::string* alt_name;
std::string* choice_name;
};
struct Alternative {
struct AlternativeValue {
std::string* alt_name;
std::string* choice_name;
Address argument;
@@ -87,12 +87,12 @@ struct TupleValue {
std::vector<TupleElement>* elements;
};
struct VariablePatternValue {
struct PatternVariableValue {
std::string* name;
const Value* type;
};
struct FunctionTypeValue {
struct FunctionType {
const Value* param;
const Value* ret;
};
@@ -123,66 +123,67 @@ struct Value {
// Return a first-class continuation represented by the
// given stack, down to the nearest enclosing `__continuation`.
static auto MakeContinuation(std::vector<Frame*> stack) -> Value*;
static auto MakeIntVal(int i) -> const Value*;
static auto MakeBoolVal(bool b) -> const Value*;
static auto MakeFunVal(std::string name, const Value* param,
const Statement* body) -> const Value*;
static auto MakePtrVal(Address addr) -> const Value*;
static auto MakeStructVal(const Value* type, const Value* inits)
static auto MakeContinuationValue(std::vector<Frame*> stack) -> Value*;
static auto MakeIntValue(int i) -> const Value*;
static auto MakeBoolValue(bool b) -> const Value*;
static auto MakeFunctionValue(std::string name, const Value* param,
const Statement* body) -> const Value*;
static auto MakePointerValue(Address addr) -> const Value*;
static auto MakeStructValue(const Value* type, const Value* inits)
-> const Value*;
static auto MakeTupleVal(std::vector<TupleElement>* elts) -> const Value*;
static auto MakeAltVal(std::string alt_name, std::string choice_name,
Address argument) -> const Value*;
static auto MakeAltCons(std::string alt_name, std::string choice_name)
static auto MakeTupleValue(std::vector<TupleElement>* elts) -> const Value*;
static auto MakeAlternativeValue(std::string alt_name,
std::string choice_name, Address argument)
-> const Value*;
static auto MakeVarPatVal(std::string name, const Value* type)
static auto MakeAlternativeConstructorValue(std::string alt_name,
std::string choice_name)
-> const Value*;
static auto MakePatternVariableValue(std::string name, const Value* type)
-> const Value*;
static auto MakeVarTypeVal(std::string name) -> const Value*;
static auto MakeIntTypeVal() -> const Value*;
static auto MakeContinuationTypeVal() -> const Value*;
static auto MakeAutoTypeVal() -> const Value*;
static auto MakeBoolTypeVal() -> const Value*;
static auto MakeTypeTypeVal() -> const Value*;
static auto MakeFunTypeVal(const Value* param, const Value* ret)
static auto MakeIntType() -> const Value*;
static auto MakeContinuationType() -> const Value*;
static auto MakeAutoType() -> const Value*;
static auto MakeBoolType() -> const Value*;
static auto MakeTypeType() -> const Value*;
static auto MakeFunctionType(const Value* param, const Value* ret)
-> const Value*;
static auto MakePtrTypeVal(const Value* type) -> const Value*;
static auto MakeStructTypeVal(std::string name, VarValues* fields,
VarValues* methods) -> const Value*;
static auto MakePointerType(const Value* type) -> const Value*;
static auto MakeStructType(std::string name, VarValues* fields,
VarValues* methods) -> const Value*;
static auto MakeUnitTypeVal() -> const Value*;
static auto MakeChoiceTypeVal(std::string name, VarValues* alts)
-> const Value*;
static auto MakeChoiceType(std::string name, VarValues* alts) -> const Value*;
// Access to alternatives
int GetInteger() const;
bool GetBoolean() const;
Function GetFunction() const;
StructConstructor GetStruct() const;
AlternativeConstructor GetAlternativeConstructor() const;
Alternative GetAlternative() const;
TupleValue GetTuple() const;
Address GetPointer() const;
int GetIntValue() const;
bool GetBoolValue() const;
FunctionValue GetFunctionValue() const;
StructValue GetStructValue() const;
AlternativeConstructorValue GetAlternativeConstructorValue() const;
AlternativeValue GetAlternativeValue() const;
TupleValue GetTupleValue() const;
Address GetPointerValue() const;
std::string* GetVariableType() const;
VariablePatternValue GetVariablePattern() const;
FunctionTypeValue GetFunctionType() const;
PatternVariableValue GetPatternVariableValue() const;
FunctionType GetFunctionType() const;
PointerType GetPointerType() const;
StructType GetStructType() const;
ChoiceType GetChoiceType() const;
ContinuationValue GetContinuation() const;
ContinuationValue GetContinuationValue() const;
private:
union {
int integer;
bool boolean;
Function fun;
StructConstructor struct_val;
AlternativeConstructor alt_cons;
Alternative alt;
FunctionValue fun;
StructValue struct_val;
AlternativeConstructorValue alt_cons;
AlternativeValue alt;
TupleValue tuple;
Address ptr;
std::string* var_type;
VariablePatternValue var_pat;
FunctionTypeValue fun_type;
PatternVariableValue var_pat;
FunctionType fun_type;
PointerType ptr_type;
StructType struct_type;
ChoiceType choice_type;
executable_semantics/syntax/paren_contents.cpp
+1 -1
View File
@@ -16,7 +16,7 @@ const Expression* ParenContents::AsExpression(int line_number) const {
}
const Expression* ParenContents::AsTuple(int line_number) const {
return Expression::MakeTuple(line_number, fields_);
return Expression::MakeTupleLiteral(line_number, fields_);
}
} // namespace Carbon
executable_semantics/syntax/paren_contents_test.cpp
+30 -30
View File
@@ -13,16 +13,16 @@ TEST(ParenContentsTest, EmptyAsExpression) {
ParenContents contents;
const Expression* expression = contents.AsExpression(/*line_num=*/1);
EXPECT_EQ(expression->line_num, 1);
ASSERT_EQ(expression->tag(), ExpressionKind::Tuple);
EXPECT_EQ(expression->GetTuple().fields.size(), 0);
ASSERT_EQ(expression->tag(), ExpressionKind::TupleLiteral);
EXPECT_EQ(expression->GetTupleLiteral().fields.size(), 0);
}
TEST(ParenContentsTest, EmptyAsTuple) {
ParenContents contents;
const Expression* tuple = contents.AsTuple(/*line_num=*/1);
EXPECT_EQ(tuple->line_num, 1);
ASSERT_EQ(tuple->tag(), ExpressionKind::Tuple);
EXPECT_EQ(tuple->GetTuple().fields.size(), 0);
ASSERT_EQ(tuple->tag(), ExpressionKind::TupleLiteral);
EXPECT_EQ(tuple->GetTupleLiteral().fields.size(), 0);
}
TEST(ParenContentsTest, UnaryNoCommaAsExpression) {
@@ -33,81 +33,81 @@ TEST(ParenContentsTest, UnaryNoCommaAsExpression) {
// )
// ```
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)}},
ParenContents::HasTrailingComma::No);
const Expression* expression = contents.AsExpression(/*line_num=*/1);
EXPECT_EQ(expression->line_num, 2);
ASSERT_EQ(expression->tag(), ExpressionKind::Integer);
ASSERT_EQ(expression->tag(), ExpressionKind::IntLiteral);
}
TEST(ParenContentsTest, UnaryNoCommaAsTuple) {
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)}},
ParenContents::HasTrailingComma::No);
const Expression* tuple = contents.AsTuple(/*line_num=*/1);
EXPECT_EQ(tuple->line_num, 1);
ASSERT_EQ(tuple->tag(), ExpressionKind::Tuple);
std::vector<FieldInitializer> fields = tuple->GetTuple().fields;
ASSERT_EQ(tuple->tag(), ExpressionKind::TupleLiteral);
std::vector<FieldInitializer> fields = tuple->GetTupleLiteral().fields;
ASSERT_EQ(fields.size(), 1);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::IntLiteral);
}
TEST(ParenContentsTest, UnaryWithCommaAsExpression) {
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)}},
ParenContents::HasTrailingComma::Yes);
const Expression* expression = contents.AsExpression(/*line_num=*/1);
EXPECT_EQ(expression->line_num, 1);
ASSERT_EQ(expression->tag(), ExpressionKind::Tuple);
std::vector<FieldInitializer> fields = expression->GetTuple().fields;
ASSERT_EQ(expression->tag(), ExpressionKind::TupleLiteral);
std::vector<FieldInitializer> fields = expression->GetTupleLiteral().fields;
ASSERT_EQ(fields.size(), 1);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::IntLiteral);
}
TEST(ParenContentsTest, UnaryWithCommaAsTuple) {
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)}},
ParenContents::HasTrailingComma::Yes);
const Expression* tuple = contents.AsTuple(/*line_num=*/1);
EXPECT_EQ(tuple->line_num, 1);
ASSERT_EQ(tuple->tag(), ExpressionKind::Tuple);
std::vector<FieldInitializer> fields = tuple->GetTuple().fields;
ASSERT_EQ(tuple->tag(), ExpressionKind::TupleLiteral);
std::vector<FieldInitializer> fields = tuple->GetTupleLiteral().fields;
ASSERT_EQ(fields.size(), 1);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::IntLiteral);
}
TEST(ParenContentsTest, BinaryAsExpression) {
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)},
{.expression = Expression::MakeInt(/*line_num=*/3, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)},
{.expression = Expression::MakeIntLiteral(/*line_num=*/3, 42)}},
ParenContents::HasTrailingComma::Yes);
const Expression* expression = contents.AsExpression(/*line_num=*/1);
EXPECT_EQ(expression->line_num, 1);
ASSERT_EQ(expression->tag(), ExpressionKind::Tuple);
std::vector<FieldInitializer> fields = expression->GetTuple().fields;
ASSERT_EQ(expression->tag(), ExpressionKind::TupleLiteral);
std::vector<FieldInitializer> fields = expression->GetTupleLiteral().fields;
ASSERT_EQ(fields.size(), 2);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[1].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::IntLiteral);
EXPECT_EQ(fields[1].expression->tag(), ExpressionKind::IntLiteral);
}
TEST(ParenContentsTest, BinaryAsTuple) {
ParenContents contents(
{{.expression = Expression::MakeInt(/*line_num=*/2, 42)},
{.expression = Expression::MakeInt(/*line_num=*/3, 42)}},
{{.expression = Expression::MakeIntLiteral(/*line_num=*/2, 42)},
{.expression = Expression::MakeIntLiteral(/*line_num=*/3, 42)}},
ParenContents::HasTrailingComma::Yes);
const Expression* tuple = contents.AsTuple(/*line_num=*/1);
EXPECT_EQ(tuple->line_num, 1);
ASSERT_EQ(tuple->tag(), ExpressionKind::Tuple);
std::vector<FieldInitializer> fields = tuple->GetTuple().fields;
ASSERT_EQ(tuple->tag(), ExpressionKind::TupleLiteral);
std::vector<FieldInitializer> fields = tuple->GetTupleLiteral().fields;
ASSERT_EQ(fields.size(), 2);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[1].expression->tag(), ExpressionKind::Integer);
EXPECT_EQ(fields[0].expression->tag(), ExpressionKind::IntLiteral);
EXPECT_EQ(fields[1].expression->tag(), ExpressionKind::IntLiteral);
}
} // namespace
executable_semantics/syntax/parser.ypp
+47 -32
View File
@@ -201,58 +201,72 @@ pattern:
;
expression:
identifier
{ $$ = Carbon::Expression::MakeVar(yylineno, $1); }
{ $$ = Carbon::Expression::MakeIdentifierExpression(yylineno, $1); }
| expression designator
{ $$ = Carbon::Expression::MakeGetField(yylineno, $1, $2); }
{ $$ = Carbon::Expression::MakeFieldAccessExpression(yylineno, $1, $2); }
| expression "[" expression "]"
{ $$ = Carbon::Expression::MakeIndex(yylineno, $1, $3); }
{ $$ = Carbon::Expression::MakeIndexExpression(yylineno, $1, $3); }
| identifier ":" expression
{ $$ = Carbon::Expression::MakeVarPat(yylineno, $1, $3); }
{
$$ = Carbon::Expression::MakePatternVariableExpression(yylineno, $1, $3);
}
| integer_literal
{ $$ = Carbon::Expression::MakeInt(yylineno, $1); }
{ $$ = Carbon::Expression::MakeIntLiteral(yylineno, $1); }
| TRUE
{ $$ = Carbon::Expression::MakeBool(yylineno, true); }
{ $$ = Carbon::Expression::MakeBoolLiteral(yylineno, true); }
| FALSE
{ $$ = Carbon::Expression::MakeBool(yylineno, false); }
{ $$ = Carbon::Expression::MakeBoolLiteral(yylineno, false); }
| INT
{ $$ = Carbon::Expression::MakeIntType(yylineno); }
{ $$ = Carbon::Expression::MakeIntTypeLiteral(yylineno); }
| BOOL
{ $$ = Carbon::Expression::MakeBoolType(yylineno); }
{ $$ = Carbon::Expression::MakeBoolTypeLiteral(yylineno); }
| TYPE
{ $$ = Carbon::Expression::MakeTypeType(yylineno); }
{ $$ = Carbon::Expression::MakeTypeTypeLiteral(yylineno); }
| AUTO
{ $$ = Carbon::Expression::MakeAutoType(yylineno); }
{ $$ = Carbon::Expression::MakeAutoTypeLiteral(yylineno); }
| CONTINUATION_TYPE
{ $$ = Carbon::Expression::MakeContinuationType(yylineno); }
{ $$ = Carbon::Expression::MakeContinuationTypeLiteral(yylineno); }
| paren_expression { $$ = $1; }
| expression EQUAL_EQUAL expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Eq, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Eq, {$1, $3}); }
| expression "+" expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Add, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Add, {$1, $3}); }
| expression "-" expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Sub, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Sub, {$1, $3}); }
| expression BINARY_STAR expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Mul, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Mul, {$1, $3}); }
| expression AND expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::And, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::And, {$1, $3}); }
| expression OR expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Or, {$1, $3}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Or, {$1, $3}); }
| NOT expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Not, {$2}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Not, {$2}); }
| "-" expression %prec UNARY_MINUS
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Neg, {$2}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Neg, {$2}); }
| PREFIX_STAR expression
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Deref, {$2}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Deref, {$2}); }
| UNARY_STAR expression %prec PREFIX_STAR
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Deref, {$2}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Deref, {$2}); }
| expression tuple
{ $$ = Carbon::Expression::MakeCall(yylineno, $1, $2); }
{ $$ = Carbon::Expression::MakeCallExpression(yylineno, $1, $2); }
| expression POSTFIX_STAR
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Ptr, {$1}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Ptr, {$1}); }
| expression UNARY_STAR
{ $$ = Carbon::Expression::MakeOp(yylineno, Carbon::Operator::Ptr, {$1}); }
{ $$ = Carbon::Expression::MakePrimitiveOperatorExpression(
yylineno, Carbon::Operator::Ptr, {$1}); }
| FNTY tuple return_type
{ $$ = Carbon::Expression::MakeFunType(yylineno, $2, $3); }
{ $$ = Carbon::Expression::MakeFunctionTypeLiteral(yylineno, $2, $3); }
;
designator: "." identifier { $$ = $2; }
;
@@ -296,8 +310,8 @@ clause:
{ $$ = new std::pair<const Carbon::Expression*, const Carbon::Statement*>($2, $4); }
| DEFAULT DBLARROW statement
{
auto vp = Carbon::Expression::MakeVarPat(yylineno, "_",
Carbon::Expression::MakeAutoType(yylineno));
auto vp = Carbon::Expression::MakePatternVariableExpression(
yylineno, "_", Carbon::Expression::MakeAutoTypeLiteral(yylineno));
$$ = new std::pair<const Carbon::Expression*, const Carbon::Statement*>(vp, $3);
}
;
@@ -350,7 +364,7 @@ statement_list:
;
return_type:
// Empty
{ $$ = Carbon::Expression::MakeTuple(yylineno, {}); }
{ $$ = Carbon::Expression::MakeTupleLiteral(yylineno, {}); }
| ARROW expression %prec FNARROW
{ $$ = $2; }
;
@@ -359,8 +373,9 @@ function_definition:
{ $$ = MakeFunDef(yylineno, $2, $4, $3, $6); }
| FN identifier tuple DBLARROW expression ";"
{
$$ = Carbon::MakeFunDef(yylineno, $2, Carbon::Expression::MakeAutoType(yylineno), $3,
Carbon::Statement::MakeReturn(yylineno, $5));
$$ = Carbon::MakeFunDef(yylineno, $2,
Carbon::Expression::MakeAutoTypeLiteral(yylineno),
$3, Carbon::Statement::MakeReturn(yylineno, $5));
}
;
function_declaration:
@@ -385,7 +400,7 @@ alternative:
| identifier
{
$$ = std::pair<std::string, const Carbon::Expression*>(
$1, Carbon::Expression::MakeTuple(yylineno, {}));
$1, Carbon::Expression::MakeTupleLiteral(yylineno, {}));
}
;
alternative_list: