From 593570593e0401d2c8cb34ced3efd0cd50e2638e Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 27 Nov 2018 19:57:45 +0000 Subject: [PATCH] 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. Reviewed-on: https://go-review.googlesource.com/c/150064 From-SVN: r266525 --- gcc/go/gofrontend/MERGE | 2 +- gcc/go/gofrontend/expressions.cc | 82 ++++++++++++++++---------------- gcc/go/gofrontend/expressions.h | 14 +++--- gcc/go/gofrontend/gogo.cc | 2 +- gcc/go/gofrontend/statements.h | 4 +- gcc/go/gofrontend/types.cc | 5 +- 6 files changed, 57 insertions(+), 52 deletions(-) diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE index 144d28545b5..71c7fcff227 100644 --- a/gcc/go/gofrontend/MERGE +++ b/gcc/go/gofrontend/MERGE @@ -1,4 +1,4 @@ -db5240278b3b62a919dd88f857e718a66be50346 +75d48ff977a2865d12b03857362ea48016a4b885 The first line of this file holds the git revision number of the last merge done from the gofrontend repository. diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc index 0e2d4fb7b00..391eb663be4 100644 --- a/gcc/go/gofrontend/expressions.cc +++ b/gcc/go/gofrontend/expressions.cc @@ -1583,7 +1583,7 @@ class Boolean_expression : public Expression { } static Expression* - do_import(Import*); + do_import(Import*, Location); protected: bool @@ -1649,17 +1649,17 @@ Boolean_expression::do_determine_type(const Type_context* context) // 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 @@ String_expression::do_export(Export_function_body* efb) const // 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 @@ String_expression::do_import(Import* imp) 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 @@ class Integer_expression : public Expression { 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 @@ Integer_expression::do_export(Export_function_body* efb) const // 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 @@ Integer_expression::do_import(Import* imp) { 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 @@ Integer_expression::do_import(Import* imp) { 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 @@ Integer_expression::do_import(Import* imp) { 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 @@ Integer_expression::do_import(Import* imp) { 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 @@ Integer_expression::do_import(Import* imp) { 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 @@ class Nil_expression : public Expression { } static Expression* - do_import(Import*); + do_import(Import*, Location); protected: bool @@ -3172,10 +3172,10 @@ class Nil_expression : public Expression // 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 @@ Type_conversion_expression::do_export(Export_function_body* efb) const // 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 @@ Unary_expression::do_export(Export_function_body* efb) const // 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 @@ Unary_expression::do_import(Import* imp) 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 @@ Binary_expression::do_export(Export_function_body* efb) const // 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 @@ Binary_expression::do_import(Import* imp) 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 @@ Expression::make_backend(Bexpression* bexpr, Type* type, Location location) // 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/gcc/go/gofrontend/expressions.h b/gcc/go/gofrontend/expressions.h index 9c3122aed61..3641b03239e 100644 --- a/gcc/go/gofrontend/expressions.h +++ b/gcc/go/gofrontend/expressions.h @@ -1014,9 +1014,11 @@ class Expression 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 @@ class String_expression : public Expression { return this->val_; } static Expression* - do_import(Import*); + do_import(Import*, Location); protected: bool @@ -1644,7 +1646,7 @@ class Type_conversion_expression : public Expression // Import a type conversion expression. static Expression* - do_import(Import*); + do_import(Import*, Location); protected: int @@ -1815,7 +1817,7 @@ class Unary_expression : public Expression 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 @@ class Binary_expression : public Expression 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/gcc/go/gofrontend/gogo.cc b/gcc/go/gofrontend/gogo.cc index cc2c65454fc..79d92e559d8 100644 --- a/gcc/go/gofrontend/gogo.cc +++ b/gcc/go/gofrontend/gogo.cc @@ -7631,7 +7631,7 @@ Named_constant::import_const(Import* imp, std::string* pname, Type** ptype, 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/gcc/go/gofrontend/statements.h b/gcc/go/gofrontend/statements.h index eef86463da0..3b5c68a3f6c 100644 --- a/gcc/go/gofrontend/statements.h +++ b/gcc/go/gofrontend/statements.h @@ -338,7 +338,9 @@ class Statement 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/gcc/go/gofrontend/types.cc b/gcc/go/gofrontend/types.cc index d4cf4ed7700..38c7f172335 100644 --- a/gcc/go/gofrontend/types.cc +++ b/gcc/go/gofrontend/types.cc @@ -6606,7 +6606,8 @@ Struct_type::do_import(Import* imp) 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 @@ Array_type::do_import(Import* imp) 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); -- 2.30.2