compiler: in range, evaluate array if it has receives or calls
The last change was incomplete, in that it did not evaluate the array
argument in some cases where it had to be evaluated. This reuses the
existing code for checking whether len/cap is constant.
Also clean up the use of _ as the second variable in a for/range,
which was previously inconsistent depending on whether the statement
used = or :=.
Updates golang/go#22313
Change-Id: I8fe09a64026aa9f8833197df2454a8581e98f60b
Reviewed-on: https://go-review.googlesource.com/91715
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
diff --git a/go/expressions.cc b/go/expressions.cc
index 715f625..3bcc5ae 100644
--- a/go/expressions.cc
+++ b/go/expressions.cc
@@ -7957,8 +7957,10 @@
int
Find_call_expression::expression(Expression** pexpr)
{
- if ((*pexpr)->call_expression() != NULL
- || (*pexpr)->receive_expression() != NULL)
+ Expression* expr = *pexpr;
+ if (!expr->is_constant()
+ && (expr->call_expression() != NULL
+ || expr->receive_expression() != NULL))
{
this->found_ = true;
return TRAVERSE_EXIT;
@@ -7966,6 +7968,24 @@
return TRAVERSE_CONTINUE;
}
+// Return whether calling len or cap on EXPR, of array type, is a
+// constant. The language spec says "the expressions len(s) and
+// cap(s) are constants if the type of s is an array or pointer to an
+// array and the expression s does not contain channel receives or
+// (non-constant) function calls."
+
+bool
+Builtin_call_expression::array_len_is_constant(Expression* expr)
+{
+ go_assert(expr->type()->deref()->array_type() != NULL
+ && !expr->type()->deref()->is_slice_type());
+ if (expr->is_constant())
+ return true;
+ Find_call_expression find_call;
+ Expression::traverse(&expr, &find_call);
+ return !find_call.found();
+}
+
// Return whether this is constant: len of a string constant, or len
// or cap of an array, or unsafe.Sizeof, unsafe.Offsetof,
// unsafe.Alignof.
@@ -7993,19 +8013,9 @@
&& !arg_type->points_to()->is_slice_type())
arg_type = arg_type->points_to();
- // The len and cap functions are only constant if there are no
- // function calls or channel operations in the arguments.
- // Otherwise we have to make the call.
- if (!arg->is_constant())
- {
- Find_call_expression find_call;
- Expression::traverse(&arg, &find_call);
- if (find_call.found())
- return false;
- }
-
if (arg_type->array_type() != NULL
- && arg_type->array_type()->length() != NULL)
+ && arg_type->array_type()->length() != NULL
+ && Builtin_call_expression::array_len_is_constant(arg))
return true;
if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
diff --git a/go/expressions.h b/go/expressions.h
index 6b00cab..18fd91b 100644
--- a/go/expressions.h
+++ b/go/expressions.h
@@ -2406,6 +2406,11 @@
is_builtin()
{ return true; }
+ // Return whether EXPR, of array type, is a constant if passed to
+ // len or cap.
+ static bool
+ array_len_is_constant(Expression* expr);
+
protected:
// This overrides Call_expression::do_lower.
Expression*
diff --git a/go/parse.cc b/go/parse.cc
index 86d3510..9700cc3 100644
--- a/go/parse.cc
+++ b/go/parse.cc
@@ -5459,8 +5459,7 @@
no->var_value()->set_type_from_range_value();
if (is_new)
any_new = true;
- if (!Gogo::is_sink_name(pti->name()))
- p_range_clause->value = Expression::make_var_reference(no, location);
+ p_range_clause->value = Expression::make_var_reference(no, location);
}
if (!any_new)
diff --git a/go/statements.cc b/go/statements.cc
index 0b1d722..c94d8cf 100644
--- a/go/statements.cc
+++ b/go/statements.cc
@@ -5311,11 +5311,12 @@
// constant, then we do not evaluate the range variable. len(x) is
// a contant if x is a string constant or if x is an array. If x is
// a constant then evaluating it won't make any difference, so the
- // only case to consider is when x is an array.
+ // only case to consider is when x is an array whose length is constant.
bool eval = true;
- if (this->value_var_ == NULL
+ if ((this->value_var_ == NULL || this->value_var_->is_sink_expression())
&& range_type->array_type() != NULL
- && !range_type->is_slice_type())
+ && !range_type->is_slice_type()
+ && Builtin_call_expression::array_len_is_constant(this->range_))
eval = false;
Location loc = this->location();
@@ -5341,7 +5342,7 @@
temp_block->add_statement(index_temp);
Temporary_statement* value_temp = NULL;
- if (this->value_var_ != NULL)
+ if (this->value_var_ != NULL && !this->value_var_->is_sink_expression())
{
value_temp = Statement::make_temporary(value_type, NULL, loc);
temp_block->add_statement(value_temp);
@@ -5393,7 +5394,7 @@
Statement* assign;
Expression* index_ref =
Expression::make_temporary_reference(index_temp, loc);
- if (this->value_var_ == NULL)
+ if (this->value_var_ == NULL || this->value_var_->is_sink_expression())
assign = Statement::make_assignment(this->index_var_, index_ref, loc);
else
{
