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);