Skip to content

Commit b53168e

Browse files
robertoraggirobertoraggi
committed
Improve substituion of non-type template parameters
1 parent b2cd1c2 commit b53168e

File tree

7 files changed

+143
-49
lines changed

7 files changed

+143
-49
lines changed

‎src/parser/cxx/ast_interpreter.cc‎

Lines changed: 40 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1634,6 +1634,10 @@ auto ASTInterpreter::ExpressionVisitor::operator()(IdExpressionAST* ast)
16341634
return enumerator->value();
16351635
}
16361636

1637+
if (auto var = symbol_cast<VariableSymbol>(ast->symbol)) {
1638+
return var->constValue();
1639+
}
1640+
16371641
return std::nullopt;
16381642
}
16391643

@@ -1989,33 +1993,49 @@ auto ASTInterpreter::ExpressionVisitor::operator()(BinaryExpressionAST* ast)
19891993

19901994
case TokenKind::T_STAR:
19911995
if (control()->is_floating_point(ast->type))
1992-
return std::visit(ArithmeticCast<double>{}, *left) +
1996+
return std::visit(ArithmeticCast<double>{}, *left) *
19931997
std::visit(ArithmeticCast<double>{}, *right);
19941998
else if (control()->is_unsigned(ast->type))
1995-
return std::visit(ArithmeticCast<std::uint64_t>{}, *left) +
1999+
return std::visit(ArithmeticCast<std::uint64_t>{}, *left) *
19962000
std::visit(ArithmeticCast<std::uint64_t>{}, *right);
19972001
else
1998-
return std::visit(ArithmeticCast<std::int64_t>{}, *left) +
2002+
return std::visit(ArithmeticCast<std::int64_t>{}, *left) *
19992003
std::visit(ArithmeticCast<std::int64_t>{}, *right);
20002004

2001-
case TokenKind::T_SLASH:
2002-
if (control()->is_floating_point(ast->type))
2003-
return std::visit(ArithmeticCast<double>{}, *left) +
2004-
std::visit(ArithmeticCast<double>{}, *right);
2005-
else if (control()->is_unsigned(ast->type))
2006-
return std::visit(ArithmeticCast<std::uint64_t>{}, *left) +
2007-
std::visit(ArithmeticCast<std::uint64_t>{}, *right);
2008-
else
2009-
return std::visit(ArithmeticCast<std::int64_t>{}, *left) +
2010-
std::visit(ArithmeticCast<std::int64_t>{}, *right);
2005+
case TokenKind::T_SLASH: {
2006+
if (control()->is_floating_point(ast->type)) {
2007+
auto l = std::visit(ArithmeticCast<double>{}, *left);
2008+
auto r = std::visit(ArithmeticCast<double>{}, *right);
2009+
if (r == 0.0) return std::nullopt;
2010+
return l / r;
2011+
}
20112012

2012-
case TokenKind::T_PERCENT:
2013-
if (control()->is_unsigned(ast->type))
2014-
return std::visit(ArithmeticCast<std::uint64_t>{}, *left) %
2015-
std::visit(ArithmeticCast<std::uint64_t>{}, *right);
2016-
else
2017-
return std::visit(ArithmeticCast<std::int64_t>{}, *left) %
2018-
std::visit(ArithmeticCast<std::int64_t>{}, *right);
2013+
if (control()->is_unsigned(ast->type)) {
2014+
auto l = std::visit(ArithmeticCast<std::uint64_t>{}, *left);
2015+
auto r = std::visit(ArithmeticCast<std::uint64_t>{}, *right);
2016+
if (r == 0) return std::nullopt;
2017+
return l / r;
2018+
}
2019+
2020+
auto l = std::visit(ArithmeticCast<std::int64_t>{}, *left);
2021+
auto r = std::visit(ArithmeticCast<std::int64_t>{}, *right);
2022+
if (r == 0) return std::nullopt;
2023+
return l / r;
2024+
}
2025+
2026+
case TokenKind::T_PERCENT: {
2027+
if (control()->is_unsigned(ast->type)) {
2028+
auto l = std::visit(ArithmeticCast<std::uint64_t>{}, *left);
2029+
auto r = std::visit(ArithmeticCast<std::uint64_t>{}, *right);
2030+
if (r == 0) return std::nullopt;
2031+
return l % r;
2032+
}
2033+
2034+
auto l = std::visit(ArithmeticCast<std::int64_t>{}, *left);
2035+
auto r = std::visit(ArithmeticCast<std::int64_t>{}, *right);
2036+
if (r == 0) return std::nullopt;
2037+
return l % r;
2038+
}
20192039

20202040
case TokenKind::T_PLUS:
20212041
if (control()->is_floating_point(ast->type))

‎src/parser/cxx/ast_rewriter.cc‎

Lines changed: 14 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -2343,35 +2343,28 @@ auto ASTRewriter::ExpressionVisitor::operator()(NestedExpressionAST* ast)
23432343

23442344
auto ASTRewriter::ExpressionVisitor::operator()(IdExpressionAST* ast)
23452345
-> ExpressionAST* {
2346-
if (auto x = symbol_cast<NonTypeParameterSymbol>(ast->symbol);
2347-
x && x->depth() == 0 && x->index() < rewrite.templateArguments_.size()) {
2348-
auto initializerPtr =
2349-
std::get_if<ExpressionAST*>(&rewrite.templateArguments_[x->index()]);
2350-
if (!initializerPtr) {
2351-
cxx_runtime_error("expected initializer for non-type template parameter");
2352-
}
2353-
2354-
auto initializer = rewrite(*initializerPtr);
2355-
2356-
if (auto eq = ast_cast<EqualInitializerAST>(initializer)) {
2357-
return eq->expression;
2358-
}
2359-
2360-
if (auto bracedInit = ast_cast<BracedInitListAST>(initializer)) {
2361-
if (bracedInit->expressionList && !bracedInit->expressionList->next) {
2362-
return bracedInit->expressionList->value;
2363-
}
2364-
}
2365-
}
2366-
23672346
auto copy = make_node<IdExpressionAST>(arena());
23682347

23692348
copy->valueCategory = ast->valueCategory;
23702349
copy->type = ast->type;
23712350
copy->nestedNameSpecifier = rewrite(ast->nestedNameSpecifier);
23722351
copy->templateLoc = ast->templateLoc;
23732352
copy->unqualifiedId = rewrite(ast->unqualifiedId);
2353+
23742354
copy->symbol = ast->symbol;
2355+
2356+
if (auto x = symbol_cast<NonTypeParameterSymbol>(copy->symbol);
2357+
x && x->depth() == 0 && x->index() < rewrite.templateArguments_.size()) {
2358+
auto initializerPtr =
2359+
std::get_if<Symbol*>(&rewrite.templateArguments_[x->index()]);
2360+
if (!initializerPtr) {
2361+
cxx_runtime_error("expected initializer for non-type template parameter");
2362+
}
2363+
2364+
copy->symbol = *initializerPtr;
2365+
copy->type = copy->symbol->type();
2366+
}
2367+
23752368
copy->isTemplateIntroduced = ast->isTemplateIntroduced;
23762369

23772370
return copy;

‎src/parser/cxx/name_printer.cc‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@ struct NamePrinter {
3636

3737
auto operator()(const ConstValue& value) const -> std::string { return {}; }
3838

39+
auto operator()(const Symbol* symbol) const -> std::string { return {}; }
40+
3941
auto operator()(ExpressionAST* value) const -> std::string { return {}; }
4042

4143
} template_argument_to_string;

‎src/parser/cxx/names_fwd.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,10 @@ class Name;
4747
CXX_FOR_EACH_NAME(PROCESS_NAME)
4848
#undef PROCESS_NAME
4949

50-
using TemplateArgument = std::variant<const Type*, ConstValue, ExpressionAST*>;
50+
class Symbol;
51+
52+
using TemplateArgument =
53+
std::variant<const Type*, Symbol*, ConstValue, ExpressionAST*>;
5154

5255
enum class IdentifierInfoKind {
5356
kTypeTrait,

‎src/parser/cxx/symbols.cc‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -563,6 +563,14 @@ void VariableSymbol::setInitializer(ExpressionAST* initializer) {
563563
initializer_ = initializer;
564564
}
565565

566+
auto VariableSymbol::constValue() const -> const std::optional<ConstValue>& {
567+
return constValue_;
568+
}
569+
570+
void VariableSymbol::setConstValue(std::optional<ConstValue> value) {
571+
constValue_ = std::move(value);
572+
}
573+
566574
FieldSymbol::FieldSymbol(Scope* enclosingScope)
567575
: Symbol(Kind, enclosingScope) {}
568576

‎src/parser/cxx/symbols.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -547,10 +547,14 @@ class VariableSymbol final : public Symbol {
547547
[[nodiscard]] auto initializer() const -> ExpressionAST*;
548548
void setInitializer(ExpressionAST*);
549549

550+
[[nodiscard]] auto constValue() const -> const std::optional<ConstValue>&;
551+
void setConstValue(std::optional<ConstValue> value);
552+
550553
private:
551554
TemplateParametersSymbol* templateParameters_ = nullptr;
552555
TemplateDeclarationAST* templateDeclaration_ = nullptr;
553556
ExpressionAST* initializer_ = nullptr;
557+
std::optional<ConstValue> constValue_;
554558

555559
union {
556560
std::uint32_t flags_{};

‎tests/api_tests/test_rewriter.cc‎

Lines changed: 71 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -89,39 +89,103 @@ using Func = void(T, const U&);
8989
TEST(Rewriter, Var) {
9090
auto source = R"(
9191
template <int i>
92-
const int c = i + 321;
92+
const int c = i + 321 + i;
9393
94-
constexpr int x = 123;
94+
constexpr int x = 123 * 2;
95+
96+
constexpr auto y = c<123 * 2>;
9597
9698
)"_cxx;
9799

100+
auto interp = ASTInterpreter{&source.unit};
101+
98102
auto control = source.control();
99103

100104
auto c = source.getAs<VariableSymbol>("c");
101105
ASSERT_TRUE(c != nullptr);
102106
auto templateDeclaration = c->templateDeclaration();
103107
ASSERT_TRUE(templateDeclaration != nullptr);
104108

109+
// extract the expression 123 * 2 from the AST
105110
auto x = source.getAs<VariableSymbol>("x");
106111
ASSERT_TRUE(x != nullptr);
107-
auto xinit = x->initializer();
112+
auto xinit = ast_cast<EqualInitializerAST>(x->initializer())->expression;
108113
ASSERT_TRUE(xinit != nullptr);
109114

115+
// synthesize const auto i = 123 * 2;
116+
117+
// ### need to set scope and location
118+
auto templArg = control->newVariableSymbol(nullptr, {});
119+
templArg->setInitializer(xinit);
120+
templArg->setType(control->add_const(x->type()));
121+
templArg->setConstValue(interp.evaluate(xinit));
122+
ASSERT_TRUE(templArg->constValue().has_value());
123+
110124
auto instance = subst(
111125
source, getTemplateBodyAs<SimpleDeclarationAST>(templateDeclaration),
112-
{xinit});
126+
{templArg});
113127

114128
auto decl = instance->initDeclaratorList->value;
115129
ASSERT_TRUE(decl != nullptr);
116130

117131
auto init = ast_cast<EqualInitializerAST>(decl->initializer);
118132
ASSERT_TRUE(init);
119133

120-
ASTInterpreter interp{&source.unit};
121-
122134
auto value = interp.evaluate(init->expression);
123135

124136
ASSERT_TRUE(value.has_value());
125137

126-
ASSERT_EQ(std::visit(ArithmeticCast<int>{}, *value), 123 + 321);
138+
ASSERT_EQ(std::visit(ArithmeticCast<int>{}, *value), 123 * 2 + 321 + 123 * 2);
139+
140+
#if false
141+
auto y = source.getAs<VariableSymbol>("y");
142+
ASSERT_TRUE(y != nullptr);
143+
auto yinit = ast_cast<EqualInitializerAST>(y->initializer())->expression;
144+
ASSERT_TRUE(yinit != nullptr);
145+
146+
auto idExpr = ast_cast<IdExpressionAST>(yinit);
147+
ASSERT_TRUE(idExpr != nullptr);
148+
149+
ASSERT_TRUE(idExpr->symbol);
150+
151+
auto templateId = ast_cast<SimpleTemplateIdAST>(idExpr->unqualifiedId);
152+
ASSERT_TRUE(templateId != nullptr);
153+
154+
// get the primary template declaration
155+
ASSERT_EQ(templateId->primaryTemplateSymbol, c);
156+
auto xx = symbol_cast<VariableSymbol>(templateId->primaryTemplateSymbol);
157+
ASSERT_TRUE(xx != nullptr);
158+
auto xxTemplDecl =
159+
getTemplateBodyAs<SimpleDeclarationAST>(xx->templateDeclaration());
160+
ASSERT_TRUE(xxTemplDecl != nullptr);
161+
162+
ASSERT_EQ(getTemplateBodyAs<SimpleDeclarationAST>(templateDeclaration),
163+
xxTemplDecl);
164+
165+
std::vector<TemplateArgument> templateArguments;
166+
for (auto arg : ListView{templateId->templateArgumentList}) {
167+
if (auto expr = ast_cast<ExpressionAST>(arg)) {
168+
// ### need to set scope and location
169+
auto templArg = control->newVariableSymbol(nullptr, {});
170+
templArg->setInitializer(xinit);
171+
templArg->setType(control->add_const(expr->type));
172+
templArg->setConstValue(interp.evaluate(expr));
173+
ASSERT_TRUE(templArg->constValue().has_value());
174+
templateArguments.push_back(templArg);
175+
}
176+
}
177+
178+
auto instance2 = subst(source, xxTemplDecl, templateArguments);
179+
180+
ASSERT_TRUE(instance2 != nullptr);
181+
182+
auto decl2 = instance2->initDeclaratorList->value;
183+
ASSERT_TRUE(decl2 != nullptr);
184+
auto init2 = ast_cast<EqualInitializerAST>(decl2->initializer);
185+
ASSERT_TRUE(init2 != nullptr);
186+
auto value2 = interp.evaluate(init2->expression);
187+
ASSERT_TRUE(value2.has_value());
188+
ASSERT_EQ(std::visit(ArithmeticCast<int>{}, *value2),
189+
123 * 2 + 321 + 123 * 2);
190+
#endif
127191
}

0 commit comments

Comments
 (0)