compiler: pass a Location to import_expression
Separate the Location that import_expression uses when creating a new
Expression from the Location used to report an error. This is a step
toward importing expressions for inlined functions. This is a pure
refactoring that does not affect compiler behavior.
Change-Id: I731bec861c59cd70c1bc8fb0f7208f8f11766565
Reviewed-on: https://go-review.googlesource.com/c/150064
Reviewed-by: Than McIntosh <thanm@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
diff --git a/go/expressions.cc b/go/expressions.cc
index 0e2d4fb..391eb66 100644
--- a/go/expressions.cc
+++ b/go/expressions.cc
@@ -1583,7 +1583,7 @@
{ }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
bool
@@ -1649,17 +1649,17 @@
// Import a boolean constant.
Expression*
-Boolean_expression::do_import(Import* imp)
+Boolean_expression::do_import(Import* imp, Location loc)
{
if (imp->peek_char() == 't')
{
imp->require_c_string("true");
- return Expression::make_boolean(true, imp->location());
+ return Expression::make_boolean(true, loc);
}
else
{
imp->require_c_string("false");
- return Expression::make_boolean(false, imp->location());
+ return Expression::make_boolean(false, loc);
}
}
@@ -1768,7 +1768,7 @@
// Import a string expression.
Expression*
-String_expression::do_import(Import* imp)
+String_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("\"");
std::string val;
@@ -1800,11 +1800,11 @@
else
{
go_error_at(imp->location(), "bad string constant");
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
}
}
- return Expression::make_string(val, imp->location());
+ return Expression::make_string(val, loc);
}
// Ast dump for string expression.
@@ -1944,7 +1944,7 @@
{ mpz_init_set(this->val_, *val); }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
// Write VAL to string dump.
static void
@@ -2151,7 +2151,7 @@
// all these types because they all start with digits.
Expression*
-Integer_expression::do_import(Import* imp)
+Integer_expression::do_import(Import* imp, Location loc)
{
std::string num = imp->read_identifier();
imp->require_c_string(" ");
@@ -2169,7 +2169,7 @@
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
if (pos == std::string::npos)
mpfr_set_ui(real, 0, GMP_RNDN);
@@ -2180,7 +2180,7 @@
{
go_error_at(imp->location(), "bad number in import data: %qs",
real_str.c_str());
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
}
@@ -2195,14 +2195,14 @@
{
go_error_at(imp->location(), "bad number in import data: %qs",
imag_str.c_str());
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
mpc_t cval;
mpc_init2(cval, mpc_precision);
mpc_set_fr_fr(cval, real, imag, MPC_RNDNN);
mpfr_clear(real);
mpfr_clear(imag);
- Expression* ret = Expression::make_complex(&cval, NULL, imp->location());
+ Expression* ret = Expression::make_complex(&cval, NULL, loc);
mpc_clear(cval);
return ret;
}
@@ -2218,13 +2218,13 @@
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
Expression* ret;
if (is_character_constant)
- ret = Expression::make_character(&val, NULL, imp->location());
+ ret = Expression::make_character(&val, NULL, loc);
else
- ret = Expression::make_integer_z(&val, NULL, imp->location());
+ ret = Expression::make_integer_z(&val, NULL, loc);
mpz_clear(val);
return ret;
}
@@ -2235,9 +2235,9 @@
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
- Expression* ret = Expression::make_float(&val, NULL, imp->location());
+ Expression* ret = Expression::make_float(&val, NULL, loc);
mpfr_clear(val);
return ret;
}
@@ -3133,7 +3133,7 @@
{ }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
bool
@@ -3172,10 +3172,10 @@
// Import a nil expression.
Expression*
-Nil_expression::do_import(Import* imp)
+Nil_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("nil");
- return Expression::make_nil(imp->location());
+ return Expression::make_nil(loc);
}
// Make a nil expression.
@@ -3623,14 +3623,14 @@
// Import a type conversion or a struct construction.
Expression*
-Type_conversion_expression::do_import(Import* imp)
+Type_conversion_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("convert(");
Type* type = imp->read_type();
imp->require_c_string(", ");
- Expression* val = Expression::import_expression(imp);
+ Expression* val = Expression::import_expression(imp, loc);
imp->require_c_string(")");
- return Expression::make_cast(type, val, imp->location());
+ return Expression::make_cast(type, val, loc);
}
// Dump ast representation for a type conversion expression.
@@ -4634,7 +4634,7 @@
// Import a unary expression.
Expression*
-Unary_expression::do_import(Import* imp)
+Unary_expression::do_import(Import* imp, Location loc)
{
Operator op;
switch (imp->get_char())
@@ -4655,8 +4655,8 @@
go_unreachable();
}
imp->require_c_string(" ");
- Expression* expr = Expression::import_expression(imp);
- return Expression::make_unary(op, expr, imp->location());
+ Expression* expr = Expression::import_expression(imp, loc);
+ return Expression::make_unary(op, expr, loc);
}
// Dump ast representation of an unary expression.
@@ -6403,11 +6403,11 @@
// Import a binary expression.
Expression*
-Binary_expression::do_import(Import* imp)
+Binary_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("(");
- Expression* left = Expression::import_expression(imp);
+ Expression* left = Expression::import_expression(imp, loc);
Operator op;
if (imp->match_c_string(" || "))
@@ -6508,14 +6508,14 @@
else
{
go_error_at(imp->location(), "unrecognized binary operator");
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
- Expression* right = Expression::import_expression(imp);
+ Expression* right = Expression::import_expression(imp, loc);
imp->require_c_string(")");
- return Expression::make_binary(op, left, right, imp->location());
+ return Expression::make_binary(op, left, right, loc);
}
// Dump ast representation of a binary expression.
@@ -16138,33 +16138,33 @@
// various class definitions.
Expression*
-Expression::import_expression(Import* imp)
+Expression::import_expression(Import* imp, Location loc)
{
int c = imp->peek_char();
if (imp->match_c_string("- ")
|| imp->match_c_string("! ")
|| imp->match_c_string("^ "))
- return Unary_expression::do_import(imp);
+ return Unary_expression::do_import(imp, loc);
else if (c == '(')
- return Binary_expression::do_import(imp);
+ return Binary_expression::do_import(imp, loc);
else if (imp->match_c_string("true")
|| imp->match_c_string("false"))
- return Boolean_expression::do_import(imp);
+ return Boolean_expression::do_import(imp, loc);
else if (c == '"')
- return String_expression::do_import(imp);
+ return String_expression::do_import(imp, loc);
else if (c == '-' || (c >= '0' && c <= '9'))
{
// This handles integers, floats and complex constants.
- return Integer_expression::do_import(imp);
+ return Integer_expression::do_import(imp, loc);
}
else if (imp->match_c_string("nil"))
- return Nil_expression::do_import(imp);
+ return Nil_expression::do_import(imp, loc);
else if (imp->match_c_string("convert"))
- return Type_conversion_expression::do_import(imp);
+ return Type_conversion_expression::do_import(imp, loc);
else
{
go_error_at(imp->location(), "import error: expected expression");
- return Expression::make_error(imp->location());
+ return Expression::make_error(loc);
}
}
diff --git a/go/expressions.h b/go/expressions.h
index 9c3122a..3641b03 100644
--- a/go/expressions.h
+++ b/go/expressions.h
@@ -1014,9 +1014,11 @@
export_expression(Export_function_body* efb) const
{ this->do_export(efb); }
- // Import an expression.
+ // Import an expression. The location should be used for the
+ // returned expression. Errors should be reported using the
+ // Import's location method.
static Expression*
- import_expression(Import*);
+ import_expression(Import*, Location);
// Return an expression which checks that VAL, of arbitrary integer type,
// is non-negative and is not more than the maximum integer value.
@@ -1565,7 +1567,7 @@
{ return this->val_; }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
bool
@@ -1644,7 +1646,7 @@
// Import a type conversion expression.
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
int
@@ -1815,7 +1817,7 @@
Location, Numeric_constant* nc, bool *issued_error);
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
// Declare that this deref does or does not require an explicit nil check.
void
@@ -1964,7 +1966,7 @@
bool* result);
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
// Report an error if OP can not be applied to TYPE. Return whether
// it can. OTYPE is the type of the other operand.
diff --git a/go/gogo.cc b/go/gogo.cc
index cc2c654..79d92e5 100644
--- a/go/gogo.cc
+++ b/go/gogo.cc
@@ -7631,7 +7631,7 @@
imp->require_c_string(" ");
}
imp->require_c_string("= ");
- *pexpr = Expression::import_expression(imp);
+ *pexpr = Expression::import_expression(imp, imp->location());
imp->require_semicolon_if_old_version();
imp->require_c_string("\n");
}
diff --git a/go/statements.h b/go/statements.h
index eef8646..3b5c68a 100644
--- a/go/statements.h
+++ b/go/statements.h
@@ -338,7 +338,9 @@
export_statement(Export_function_body* efb)
{ this->do_export_statement(efb); }
- // Read a statement from export data.
+ // Read a statement from export data. The location should be used
+ // for the returned statement. Errors should be reported using the
+ // Import_function_body's location method.
static Statement*
import_statement(Import_function_body*, Location);
diff --git a/go/types.cc b/go/types.cc
index d4cf4ed..38c7f17 100644
--- a/go/types.cc
+++ b/go/types.cc
@@ -6606,7 +6606,8 @@
if (imp->peek_char() == ' ')
{
imp->advance(1);
- Expression* expr = Expression::import_expression(imp);
+ Expression* expr = Expression::import_expression(imp,
+ imp->location());
String_expression* sexpr = expr->string_expression();
go_assert(sexpr != NULL);
sf.set_tag(sexpr->val());
@@ -7568,7 +7569,7 @@
if (imp->peek_char() == ']')
length = NULL;
else
- length = Expression::import_expression(imp);
+ length = Expression::import_expression(imp, imp->location());
imp->require_c_string("] ");
Type* element_type = imp->read_type();
return Type::make_array_type(element_type, length);
