gcc/go/gofrontend/expressions.h

   1 // expressions.h -- Go frontend expression handling.     -*- C++ -*-
   2
   3 // Copyright 2009 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 #ifndef GO_EXPRESSIONS_H
   8 #define GO_EXPRESSIONS_H
   9
  10 #include <gmp.h>
  11 #include <mpfr.h>
  12
  13 #include "operator.h"
  14
  15 class Gogo;
  16 class Translate_context;
  17 class Traverse;
  18 class Statement_inserter;
  19 class Type;
  20 struct Type_context;
  21 class Integer_type;
  22 class Float_type;
  23 class Complex_type;
  24 class Function_type;
  25 class Map_type;
  26 class Struct_type;
  27 class Struct_field;
  28 class Expression_list;
  29 class Var_expression;
  30 class Temporary_reference_expression;
  31 class Set_and_use_temporary_expression;
  32 class String_expression;
  33 class Binary_expression;
  34 class Call_expression;
  35 class Func_expression;
  36 class Unknown_expression;
  37 class Index_expression;
  38 class Map_index_expression;
  39 class Bound_method_expression;
  40 class Field_reference_expression;
  41 class Interface_field_reference_expression;
  42 class Type_guard_expression;
  43 class Receive_expression;
  44 class Numeric_constant;
  45 class Named_object;
  46 class Export;
  47 class Import;
  48 class Temporary_statement;
  49 class Label;
  50 class Ast_dump_context;
  51 class String_dump;
  52
  53 // The base class for all expressions.
  54
  55 class Expression
  56 {
  57  public:
  58   // The types of expressions.
  59   enum Expression_classification
  60   {
  61     EXPRESSION_ERROR,
  62     EXPRESSION_TYPE,
  63     EXPRESSION_UNARY,
  64     EXPRESSION_BINARY,
  65     EXPRESSION_CONST_REFERENCE,
  66     EXPRESSION_VAR_REFERENCE,
  67     EXPRESSION_TEMPORARY_REFERENCE,
  68     EXPRESSION_SET_AND_USE_TEMPORARY,
  69     EXPRESSION_SINK,
  70     EXPRESSION_FUNC_REFERENCE,
  71     EXPRESSION_UNKNOWN_REFERENCE,
  72     EXPRESSION_BOOLEAN,
  73     EXPRESSION_STRING,
  74     EXPRESSION_INTEGER,
  75     EXPRESSION_FLOAT,
  76     EXPRESSION_COMPLEX,
  77     EXPRESSION_NIL,
  78     EXPRESSION_IOTA,
  79     EXPRESSION_CALL,
  80     EXPRESSION_CALL_RESULT,
  81     EXPRESSION_BOUND_METHOD,
  82     EXPRESSION_INDEX,
  83     EXPRESSION_ARRAY_INDEX,
  84     EXPRESSION_STRING_INDEX,
  85     EXPRESSION_MAP_INDEX,
  86     EXPRESSION_SELECTOR,
  87     EXPRESSION_FIELD_REFERENCE,
  88     EXPRESSION_INTERFACE_FIELD_REFERENCE,
  89     EXPRESSION_ALLOCATION,
  90     EXPRESSION_TYPE_GUARD,
  91     EXPRESSION_CONVERSION,
  92     EXPRESSION_UNSAFE_CONVERSION,
  93     EXPRESSION_STRUCT_CONSTRUCTION,
  94     EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
  95     EXPRESSION_OPEN_ARRAY_CONSTRUCTION,
  96     EXPRESSION_MAP_CONSTRUCTION,
  97     EXPRESSION_COMPOSITE_LITERAL,
  98     EXPRESSION_HEAP_COMPOSITE,
  99     EXPRESSION_RECEIVE,
 100     EXPRESSION_TYPE_DESCRIPTOR,
 101     EXPRESSION_TYPE_INFO,
 102     EXPRESSION_STRUCT_FIELD_OFFSET,
 103     EXPRESSION_MAP_DESCRIPTOR,
 104     EXPRESSION_LABEL_ADDR
 105   };
 106
 107   Expression(Expression_classification, Location);
 108
 109   virtual ~Expression();
 110
 111   // Make an error expression.  This is used when a parse error occurs
 112   // to prevent cascading errors.
 113   static Expression*
 114   make_error(Location);
 115
 116   // Make an expression which is really a type.  This is used during
 117   // parsing.
 118   static Expression*
 119   make_type(Type*, Location);
 120
 121   // Make a unary expression.
 122   static Expression*
 123   make_unary(Operator, Expression*, Location);
 124
 125   // Make a binary expression.
 126   static Expression*
 127   make_binary(Operator, Expression*, Expression*, Location);
 128
 129   // Make a reference to a constant in an expression.
 130   static Expression*
 131   make_const_reference(Named_object*, Location);
 132
 133   // Make a reference to a variable in an expression.
 134   static Expression*
 135   make_var_reference(Named_object*, Location);
 136
 137   // Make a reference to a temporary variable.  Temporary variables
 138   // are always created by a single statement, which is what we use to
 139   // refer to them.
 140   static Temporary_reference_expression*
 141   make_temporary_reference(Temporary_statement*, Location);
 142
 143   // Make an expressions which sets a temporary variable and then
 144   // evaluates to a reference to that temporary variable.  This is
 145   // used to set a temporary variable while retaining the order of
 146   // evaluation.
 147   static Set_and_use_temporary_expression*
 148   make_set_and_use_temporary(Temporary_statement*, Expression*, Location);
 149
 150   // Make a sink expression--a reference to the blank identifier _.
 151   static Expression*
 152   make_sink(Location);
 153
 154   // Make a reference to a function in an expression.
 155   static Expression*
 156   make_func_reference(Named_object*, Expression* closure, Location);
 157
 158   // Make a reference to an unknown name.  In a correct program this
 159   // will always be lowered to a real const/var/func reference.
 160   static Unknown_expression*
 161   make_unknown_reference(Named_object*, Location);
 162
 163   // Make a constant bool expression.
 164   static Expression*
 165   make_boolean(bool val, Location);
 166
 167   // Make a constant string expression.
 168   static Expression*
 169   make_string(const std::string&, Location);
 170
 171   // Make a character constant expression.  TYPE should be NULL for an
 172   // abstract type.
 173   static Expression*
 174   make_character(const mpz_t*, Type*, Location);
 175
 176   // Make a constant integer expression.  TYPE should be NULL for an
 177   // abstract type.
 178   static Expression*
 179   make_integer(const mpz_t*, Type*, Location);
 180
 181   // Make a constant float expression.  TYPE should be NULL for an
 182   // abstract type.
 183   static Expression*
 184   make_float(const mpfr_t*, Type*, Location);
 185
 186   // Make a constant complex expression.  TYPE should be NULL for an
 187   // abstract type.
 188   static Expression*
 189   make_complex(const mpfr_t* real, const mpfr_t* imag, Type*, Location);
 190
 191   // Make a nil expression.
 192   static Expression*
 193   make_nil(Location);
 194
 195   // Make an iota expression.  This is used for the predeclared
 196   // constant iota.
 197   static Expression*
 198   make_iota();
 199
 200   // Make a call expression.
 201   static Call_expression*
 202   make_call(Expression* func, Expression_list* args, bool is_varargs,
 203             Location);
 204
 205   // Make a reference to a specific result of a call expression which
 206   // returns a tuple.
 207   static Expression*
 208   make_call_result(Call_expression*, unsigned int index);
 209
 210   // Make an expression which is a method bound to its first
 211   // parameter.
 212   static Bound_method_expression*
 213   make_bound_method(Expression* object, Named_object* method, Location);
 214
 215   // Make an index or slice expression.  This is a parser expression
 216   // which represents LEFT[START:END].  END may be NULL, meaning an
 217   // index rather than a slice.  At parse time we may not know the
 218   // type of LEFT.  After parsing this is lowered to an array index, a
 219   // string index, or a map index.
 220   static Expression*
 221   make_index(Expression* left, Expression* start, Expression* end,
 222              Location);
 223
 224   // Make an array index expression.  END may be NULL, in which case
 225   // this is an lvalue.
 226   static Expression*
 227   make_array_index(Expression* array, Expression* start, Expression* end,
 228                    Location);
 229
 230   // Make a string index expression.  END may be NULL.  This is never
 231   // an lvalue.
 232   static Expression*
 233   make_string_index(Expression* string, Expression* start, Expression* end,
 234                     Location);
 235
 236   // Make a map index expression.  This is an lvalue.
 237   static Map_index_expression*
 238   make_map_index(Expression* map, Expression* val, Location);
 239
 240   // Make a selector.  This is a parser expression which represents
 241   // LEFT.NAME.  At parse time we may not know the type of the left
 242   // hand side.
 243   static Expression*
 244   make_selector(Expression* left, const std::string& name, Location);
 245
 246   // Make a reference to a field in a struct.
 247   static Field_reference_expression*
 248   make_field_reference(Expression*, unsigned int field_index, Location);
 249
 250   // Make a reference to a field of an interface, with an associated
 251   // object.
 252   static Expression*
 253   make_interface_field_reference(Expression*, const std::string&,
 254                                  Location);
 255
 256   // Make an allocation expression.
 257   static Expression*
 258   make_allocation(Type*, Location);
 259
 260   // Make a type guard expression.
 261   static Expression*
 262   make_type_guard(Expression*, Type*, Location);
 263
 264   // Make a type cast expression.
 265   static Expression*
 266   make_cast(Type*, Expression*, Location);
 267
 268   // Make an unsafe type cast expression.  This is only used when
 269   // passing parameter to builtin functions that are part of the Go
 270   // runtime.
 271   static Expression*
 272   make_unsafe_cast(Type*, Expression*, Location);
 273
 274   // Make a composite literal.  The DEPTH parameter is how far down we
 275   // are in a list of composite literals with omitted types.
 276   static Expression*
 277   make_composite_literal(Type*, int depth, bool has_keys, Expression_list*,
 278                          Location);
 279
 280   // Make a struct composite literal.
 281   static Expression*
 282   make_struct_composite_literal(Type*, Expression_list*, Location);
 283
 284   // Make a slice composite literal.
 285   static Expression*
 286   make_slice_composite_literal(Type*, Expression_list*, Location);
 287
 288   // Take a composite literal and allocate it on the heap.
 289   static Expression*
 290   make_heap_composite(Expression*, Location);
 291
 292   // Make a receive expression.  VAL is NULL for a unary receive.
 293   static Receive_expression*
 294   make_receive(Expression* channel, Location);
 295
 296   // Make an expression which evaluates to the address of the type
 297   // descriptor for TYPE.
 298   static Expression*
 299   make_type_descriptor(Type* type, Location);
 300
 301   // Make an expression which evaluates to some characteristic of a
 302   // type.  These are only used for type descriptors, so there is no
 303   // location parameter.
 304   enum Type_info
 305     {
 306       // The size of a value of the type.
 307       TYPE_INFO_SIZE,
 308       // The required alignment of a value of the type.
 309       TYPE_INFO_ALIGNMENT,
 310       // The required alignment of a value of the type when used as a
 311       // field in a struct.
 312       TYPE_INFO_FIELD_ALIGNMENT
 313     };
 314
 315   static Expression*
 316   make_type_info(Type* type, Type_info);
 317
 318   // Make an expression which evaluates to the offset of a field in a
 319   // struct.  This is only used for type descriptors, so there is no
 320   // location parameter.
 321   static Expression*
 322   make_struct_field_offset(Struct_type*, const Struct_field*);
 323
 324   // Make an expression which evaluates to the address of the map
 325   // descriptor for TYPE.
 326   static Expression*
 327   make_map_descriptor(Map_type* type, Location);
 328
 329   // Make an expression which evaluates to the address of an unnamed
 330   // label.
 331   static Expression*
 332   make_label_addr(Label*, Location);
 333
 334   // Return the expression classification.
 335   Expression_classification
 336   classification() const
 337   { return this->classification_; }
 338
 339   // Return the location of the expression.
 340   Location
 341   location() const
 342   { return this->location_; }
 343
 344   // Return whether this is a constant expression.
 345   bool
 346   is_constant() const
 347   { return this->do_is_constant(); }
 348
 349   // If this is not a numeric constant, return false.  If it is one,
 350   // return true, and set VAL to hold the value.
 351   bool
 352   numeric_constant_value(Numeric_constant* val) const
 353   { return this->do_numeric_constant_value(val); }
 354
 355   // If this is not a constant expression with string type, return
 356   // false.  If it is one, return true, and set VAL to the value.
 357   bool
 358   string_constant_value(std::string* val) const
 359   { return this->do_string_constant_value(val); }
 360
 361   // This is called if the value of this expression is being
 362   // discarded.  This issues warnings about computed values being
 363   // unused.
 364   void
 365   discarding_value()
 366   { this->do_discarding_value(); }
 367
 368   // Return whether this is an error expression.
 369   bool
 370   is_error_expression() const
 371   { return this->classification_ == EXPRESSION_ERROR; }
 372
 373   // Return whether this expression really represents a type.
 374   bool
 375   is_type_expression() const
 376   { return this->classification_ == EXPRESSION_TYPE; }
 377
 378   // If this is a variable reference, return the Var_expression
 379   // structure.  Otherwise, return NULL.  This is a controlled dynamic
 380   // cast.
 381   Var_expression*
 382   var_expression()
 383   { return this->convert<Var_expression, EXPRESSION_VAR_REFERENCE>(); }
 384
 385   const Var_expression*
 386   var_expression() const
 387   { return this->convert<const Var_expression, EXPRESSION_VAR_REFERENCE>(); }
 388
 389   // If this is a reference to a temporary variable, return the
 390   // Temporary_reference_expression.  Otherwise, return NULL.
 391   Temporary_reference_expression*
 392   temporary_reference_expression()
 393   {
 394     return this->convert<Temporary_reference_expression,
 395                          EXPRESSION_TEMPORARY_REFERENCE>();
 396   }
 397
 398   // If this is a set-and-use-temporary, return the
 399   // Set_and_use_temporary_expression.  Otherwise, return NULL.
 400   Set_and_use_temporary_expression*
 401   set_and_use_temporary_expression()
 402   {
 403     return this->convert<Set_and_use_temporary_expression,
 404                          EXPRESSION_SET_AND_USE_TEMPORARY>();
 405   }
 406
 407   // Return whether this is a sink expression.
 408   bool
 409   is_sink_expression() const
 410   { return this->classification_ == EXPRESSION_SINK; }
 411
 412   // If this is a string expression, return the String_expression
 413   // structure.  Otherwise, return NULL.
 414   String_expression*
 415   string_expression()
 416   { return this->convert<String_expression, EXPRESSION_STRING>(); }
 417
 418   // Return whether this is the expression nil.
 419   bool
 420   is_nil_expression() const
 421   { return this->classification_ == EXPRESSION_NIL; }
 422
 423   // If this is an indirection through a pointer, return the
 424   // expression being pointed through.  Otherwise return this.
 425   Expression*
 426   deref();
 427
 428   // If this is a binary expression, return the Binary_expression
 429   // structure.  Otherwise return NULL.
 430   Binary_expression*
 431   binary_expression()
 432   { return this->convert<Binary_expression, EXPRESSION_BINARY>(); }
 433
 434   // If this is a call expression, return the Call_expression
 435   // structure.  Otherwise, return NULL.  This is a controlled dynamic
 436   // cast.
 437   Call_expression*
 438   call_expression()
 439   { return this->convert<Call_expression, EXPRESSION_CALL>(); }
 440
 441   // If this is an expression which refers to a function, return the
 442   // Func_expression structure.  Otherwise, return NULL.
 443   Func_expression*
 444   func_expression()
 445   { return this->convert<Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
 446
 447   const Func_expression*
 448   func_expression() const
 449   { return this->convert<const Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
 450
 451   // If this is an expression which refers to an unknown name, return
 452   // the Unknown_expression structure.  Otherwise, return NULL.
 453   Unknown_expression*
 454   unknown_expression()
 455   { return this->convert<Unknown_expression, EXPRESSION_UNKNOWN_REFERENCE>(); }
 456
 457   const Unknown_expression*
 458   unknown_expression() const
 459   {
 460     return this->convert<const Unknown_expression,
 461                          EXPRESSION_UNKNOWN_REFERENCE>();
 462   }
 463
 464   // If this is an index expression, return the Index_expression
 465   // structure.  Otherwise, return NULL.
 466   Index_expression*
 467   index_expression()
 468   { return this->convert<Index_expression, EXPRESSION_INDEX>(); }
 469
 470   // If this is an expression which refers to indexing in a map,
 471   // return the Map_index_expression structure.  Otherwise, return
 472   // NULL.
 473   Map_index_expression*
 474   map_index_expression()
 475   { return this->convert<Map_index_expression, EXPRESSION_MAP_INDEX>(); }
 476
 477   // If this is a bound method expression, return the
 478   // Bound_method_expression structure.  Otherwise, return NULL.
 479   Bound_method_expression*
 480   bound_method_expression()
 481   { return this->convert<Bound_method_expression, EXPRESSION_BOUND_METHOD>(); }
 482
 483   // If this is a reference to a field in a struct, return the
 484   // Field_reference_expression structure.  Otherwise, return NULL.
 485   Field_reference_expression*
 486   field_reference_expression()
 487   {
 488     return this->convert<Field_reference_expression,
 489                          EXPRESSION_FIELD_REFERENCE>();
 490   }
 491
 492   // If this is a reference to a field in an interface, return the
 493   // Interface_field_reference_expression structure.  Otherwise,
 494   // return NULL.
 495   Interface_field_reference_expression*
 496   interface_field_reference_expression()
 497   {
 498     return this->convert<Interface_field_reference_expression,
 499                          EXPRESSION_INTERFACE_FIELD_REFERENCE>();
 500   }
 501
 502   // If this is a type guard expression, return the
 503   // Type_guard_expression structure.  Otherwise, return NULL.
 504   Type_guard_expression*
 505   type_guard_expression()
 506   { return this->convert<Type_guard_expression, EXPRESSION_TYPE_GUARD>(); }
 507
 508   // If this is a receive expression, return the Receive_expression
 509   // structure.  Otherwise, return NULL.
 510   Receive_expression*
 511   receive_expression()
 512   { return this->convert<Receive_expression, EXPRESSION_RECEIVE>(); }
 513
 514   // Return true if this is a composite literal.
 515   bool
 516   is_composite_literal() const;
 517
 518   // Return true if this is a composite literal which is not constant.
 519   bool
 520   is_nonconstant_composite_literal() const;
 521
 522   // Return true if this is a reference to a local variable.
 523   bool
 524   is_local_variable() const;
 525
 526   // Traverse an expression.
 527   static int
 528   traverse(Expression**, Traverse*);
 529
 530   // Traverse subexpressions of this expression.
 531   int
 532   traverse_subexpressions(Traverse*);
 533
 534   // Lower an expression.  This is called immediately after parsing.
 535   // FUNCTION is the function we are in; it will be NULL for an
 536   // expression initializing a global variable.  INSERTER may be used
 537   // to insert statements before the statement or initializer
 538   // containing this expression; it is normally used to create
 539   // temporary variables.  IOTA_VALUE is the value that we should give
 540   // to any iota expressions.  This function must resolve expressions
 541   // which could not be fully parsed into their final form.  It
 542   // returns the same Expression or a new one.
 543   Expression*
 544   lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter,
 545         int iota_value)
 546   { return this->do_lower(gogo, function, inserter, iota_value); }
 547
 548   // Determine the real type of an expression with abstract integer,
 549   // floating point, or complex type.  TYPE_CONTEXT describes the
 550   // expected type.
 551   void
 552   determine_type(const Type_context*);
 553
 554   // Check types in an expression.
 555   void
 556   check_types(Gogo* gogo)
 557   { this->do_check_types(gogo); }
 558
 559   // Determine the type when there is no context.
 560   void
 561   determine_type_no_context();
 562
 563   // Return the current type of the expression.  This may be changed
 564   // by determine_type.
 565   Type*
 566   type()
 567   { return this->do_type(); }
 568
 569   // Return a copy of an expression.
 570   Expression*
 571   copy()
 572   { return this->do_copy(); }
 573
 574   // Return whether the expression is addressable--something which may
 575   // be used as the operand of the unary & operator.
 576   bool
 577   is_addressable() const
 578   { return this->do_is_addressable(); }
 579
 580   // Note that we are taking the address of this expression.  ESCAPES
 581   // is true if this address escapes the current function.
 582   void
 583   address_taken(bool escapes)
 584   { this->do_address_taken(escapes); }
 585
 586   // Return whether this expression must be evaluated in order
 587   // according to the order of evaluation rules.  This is basically
 588   // true of all expressions with side-effects.
 589   bool
 590   must_eval_in_order() const
 591   { return this->do_must_eval_in_order(); }
 592
 593   // Return whether subexpressions of this expression must be
 594   // evaluated in order.  This is true of index expressions and
 595   // pointer indirections.  This sets *SKIP to the number of
 596   // subexpressions to skip during traversing, as index expressions
 597   // only requiring moving the index, not the array.
 598   bool
 599   must_eval_subexpressions_in_order(int* skip) const
 600   {
 601     *skip = 0;
 602     return this->do_must_eval_subexpressions_in_order(skip);
 603   }
 604
 605   // Return the tree for this expression.
 606   tree
 607   get_tree(Translate_context*);
 608
 609   // Return a tree handling any conversions which must be done during
 610   // assignment.
 611   static tree
 612   convert_for_assignment(Translate_context*, Type* lhs_type, Type* rhs_type,
 613                          tree rhs_tree, Location location);
 614
 615   // Return a tree converting a value of one interface type to another
 616   // interface type.  If FOR_TYPE_GUARD is true this is for a type
 617   // assertion.
 618   static tree
 619   convert_interface_to_interface(Translate_context*, Type* lhs_type,
 620                                  Type* rhs_type, tree rhs_tree,
 621                                  bool for_type_guard, Location);
 622
 623   // Return a tree implementing the comparison LHS_TREE OP RHS_TREE.
 624   // TYPE is the type of both sides.
 625   static tree
 626   comparison_tree(Translate_context*, Operator op, Type* left_type,
 627                   tree left_tree, Type* right_type, tree right_tree,
 628                   Location);
 629
 630   // Return a tree for the multi-precision integer VAL in TYPE.
 631   static tree
 632   integer_constant_tree(mpz_t val, tree type);
 633
 634   // Return a tree for the floating point value VAL in TYPE.
 635   static tree
 636   float_constant_tree(mpfr_t val, tree type);
 637
 638   // Return a tree for the complex value REAL/IMAG in TYPE.
 639   static tree
 640   complex_constant_tree(mpfr_t real, mpfr_t imag, tree type);
 641
 642   // Export the expression.  This is only used for constants.  It will
 643   // be used for things like values of named constants and sizes of
 644   // arrays.
 645   void
 646   export_expression(Export* exp) const
 647   { this->do_export(exp); }
 648
 649   // Import an expression.
 650   static Expression*
 651   import_expression(Import*);
 652
 653   // Return a tree which checks that VAL, of arbitrary integer type,
 654   // is non-negative and is not more than the maximum value of
 655   // BOUND_TYPE.  If SOFAR is not NULL, it is or'red into the result.
 656   // The return value may be NULL if SOFAR is NULL.
 657   static tree
 658   check_bounds(tree val, tree bound_type, tree sofar, Location);
 659
 660   // Dump an expression to a dump constext.
 661   void
 662   dump_expression(Ast_dump_context*) const;
 663
 664  protected:
 665   // May be implemented by child class: traverse the expressions.
 666   virtual int
 667   do_traverse(Traverse*);
 668
 669   // Return a lowered expression.
 670   virtual Expression*
 671   do_lower(Gogo*, Named_object*, Statement_inserter*, int)
 672   { return this; }
 673
 674   // Return whether this is a constant expression.
 675   virtual bool
 676   do_is_constant() const
 677   { return false; }
 678
 679   // Return whether this is a constant expression of numeric type, and
 680   // set the Numeric_constant to the value.
 681   virtual bool
 682   do_numeric_constant_value(Numeric_constant*) const
 683   { return false; }
 684
 685   // Return whether this is a constant expression of string type, and
 686   // set VAL to the value.
 687   virtual bool
 688   do_string_constant_value(std::string*) const
 689   { return false; }
 690
 691   // Called by the parser if the value is being discarded.
 692   virtual void
 693   do_discarding_value();
 694
 695   // Child class holds type.
 696   virtual Type*
 697   do_type() = 0;
 698
 699   // Child class implements determining type information.
 700   virtual void
 701   do_determine_type(const Type_context*) = 0;
 702
 703   // Child class implements type checking if needed.
 704   virtual void
 705   do_check_types(Gogo*)
 706   { }
 707
 708   // Child class implements copying.
 709   virtual Expression*
 710   do_copy() = 0;
 711
 712   // Child class implements whether the expression is addressable.
 713   virtual bool
 714   do_is_addressable() const
 715   { return false; }
 716
 717   // Child class implements taking the address of an expression.
 718   virtual void
 719   do_address_taken(bool)
 720   { }
 721
 722   // Child class implements whether this expression must be evaluated
 723   // in order.
 724   virtual bool
 725   do_must_eval_in_order() const
 726   { return false; }
 727
 728   // Child class implements whether this expressions requires that
 729   // subexpressions be evaluated in order.  The child implementation
 730   // may set *SKIP if it should be non-zero.
 731   virtual bool
 732   do_must_eval_subexpressions_in_order(int* /* skip */) const
 733   { return false; }
 734
 735   // Child class implements conversion to tree.
 736   virtual tree
 737   do_get_tree(Translate_context*) = 0;
 738
 739   // Child class implements export.
 740   virtual void
 741   do_export(Export*) const;
 742
 743   // For children to call to give an error for an unused value.
 744   void
 745   unused_value_error();
 746
 747   // For children to call when they detect that they are in error.
 748   void
 749   set_is_error();
 750
 751   // For children to call to report an error conveniently.
 752   void
 753   report_error(const char*);
 754
 755   // Child class implements dumping to a dump context.
 756   virtual void
 757   do_dump_expression(Ast_dump_context*) const = 0;
 758
 759  private:
 760   // Convert to the desired statement classification, or return NULL.
 761   // This is a controlled dynamic cast.
 762   template<typename Expression_class,
 763            Expression_classification expr_classification>
 764   Expression_class*
 765   convert()
 766   {
 767     return (this->classification_ == expr_classification
 768             ? static_cast<Expression_class*>(this)
 769             : NULL);
 770   }
 771
 772   template<typename Expression_class,
 773            Expression_classification expr_classification>
 774   const Expression_class*
 775   convert() const
 776   {
 777     return (this->classification_ == expr_classification
 778             ? static_cast<const Expression_class*>(this)
 779             : NULL);
 780   }
 781
 782   static tree
 783   convert_type_to_interface(Translate_context*, Type*, Type*, tree,
 784                             Location);
 785
 786   static tree
 787   get_interface_type_descriptor(Translate_context*, Type*, tree,
 788                                 Location);
 789
 790   static tree
 791   convert_interface_to_type(Translate_context*, Type*, Type*, tree,
 792                             Location);
 793
 794   // The expression classification.
 795   Expression_classification classification_;
 796   // The location in the input file.
 797   Location location_;
 798 };
 799
 800 // A list of Expressions.
 801
 802 class Expression_list
 803 {
 804  public:
 805   Expression_list()
 806     : entries_()
 807   { }
 808
 809   // Return whether the list is empty.
 810   bool
 811   empty() const
 812   { return this->entries_.empty(); }
 813
 814   // Return the number of entries in the list.
 815   size_t
 816   size() const
 817   { return this->entries_.size(); }
 818
 819   // Add an entry to the end of the list.
 820   void
 821   push_back(Expression* expr)
 822   { this->entries_.push_back(expr); }
 823
 824   void
 825   append(Expression_list* add)
 826   { this->entries_.insert(this->entries_.end(), add->begin(), add->end()); }
 827
 828   // Reserve space in the list.
 829   void
 830   reserve(size_t size)
 831   { this->entries_.reserve(size); }
 832
 833   // Traverse the expressions in the list.
 834   int
 835   traverse(Traverse*);
 836
 837   // Copy the list.
 838   Expression_list*
 839   copy();
 840
 841   // Return true if the list contains an error expression.
 842   bool
 843   contains_error() const;
 844
 845   // Return the first and last elements.
 846   Expression*&
 847   front()
 848   { return this->entries_.front(); }
 849
 850   Expression*
 851   front() const
 852   { return this->entries_.front(); }
 853
 854   Expression*&
 855   back()
 856   { return this->entries_.back(); }
 857
 858   Expression*
 859   back() const
 860   { return this->entries_.back(); }
 861
 862   // Iterators.
 863
 864   typedef std::vector<Expression*>::iterator iterator;
 865   typedef std::vector<Expression*>::const_iterator const_iterator;
 866
 867   iterator
 868   begin()
 869   { return this->entries_.begin(); }
 870
 871   const_iterator
 872   begin() const
 873   { return this->entries_.begin(); }
 874
 875   iterator
 876   end()
 877   { return this->entries_.end(); }
 878
 879   const_iterator
 880   end() const
 881   { return this->entries_.end(); }
 882
 883   // Erase an entry.
 884   void
 885   erase(iterator p)
 886   { this->entries_.erase(p); }
 887
 888  private:
 889   std::vector<Expression*> entries_;
 890 };
 891
 892 // An abstract base class for an expression which is only used by the
 893 // parser, and is lowered in the lowering pass.
 894
 895 class Parser_expression : public Expression
 896 {
 897  public:
 898   Parser_expression(Expression_classification classification,
 899                     Location location)
 900     : Expression(classification, location)
 901   { }
 902
 903  protected:
 904   virtual Expression*
 905   do_lower(Gogo*, Named_object*, Statement_inserter*, int) = 0;
 906
 907   Type*
 908   do_type();
 909
 910   void
 911   do_determine_type(const Type_context*)
 912   { go_unreachable(); }
 913
 914   void
 915   do_check_types(Gogo*)
 916   { go_unreachable(); }
 917
 918   tree
 919   do_get_tree(Translate_context*)
 920   { go_unreachable(); }
 921 };
 922
 923 // An expression which is simply a variable.
 924
 925 class Var_expression : public Expression
 926 {
 927  public:
 928   Var_expression(Named_object* variable, Location location)
 929     : Expression(EXPRESSION_VAR_REFERENCE, location),
 930       variable_(variable)
 931   { }
 932
 933   // Return the variable.
 934   Named_object*
 935   named_object() const
 936   { return this->variable_; }
 937
 938  protected:
 939   Expression*
 940   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
 941
 942   Type*
 943   do_type();
 944
 945   void
 946   do_determine_type(const Type_context*);
 947
 948   Expression*
 949   do_copy()
 950   { return this; }
 951
 952   bool
 953   do_is_addressable() const
 954   { return true; }
 955
 956   void
 957   do_address_taken(bool);
 958
 959   tree
 960   do_get_tree(Translate_context*);
 961
 962   void
 963   do_dump_expression(Ast_dump_context*) const;
 964
 965  private:
 966   // The variable we are referencing.
 967   Named_object* variable_;
 968 };
 969
 970 // A reference to a temporary variable.
 971
 972 class Temporary_reference_expression : public Expression
 973 {
 974  public:
 975   Temporary_reference_expression(Temporary_statement* statement,
 976                                  Location location)
 977     : Expression(EXPRESSION_TEMPORARY_REFERENCE, location),
 978       statement_(statement), is_lvalue_(false)
 979   { }
 980
 981   // Indicate that this reference appears on the left hand side of an
 982   // assignment statement.
 983   void
 984   set_is_lvalue()
 985   { this->is_lvalue_ = true; }
 986
 987  protected:
 988   Type*
 989   do_type();
 990
 991   void
 992   do_determine_type(const Type_context*)
 993   { }
 994
 995   Expression*
 996   do_copy()
 997   { return make_temporary_reference(this->statement_, this->location()); }
 998
 999   bool
1000   do_is_addressable() const
1001   { return true; }
1002
1003   void
1004   do_address_taken(bool);
1005
1006   tree
1007   do_get_tree(Translate_context*);
1008
1009   void
1010   do_dump_expression(Ast_dump_context*) const;
1011
1012  private:
1013   // The statement where the temporary variable is defined.
1014   Temporary_statement* statement_;
1015   // Whether this reference appears on the left hand side of an
1016   // assignment statement.
1017   bool is_lvalue_;
1018 };
1019
1020 // Set and use a temporary variable.
1021
1022 class Set_and_use_temporary_expression : public Expression
1023 {
1024  public:
1025   Set_and_use_temporary_expression(Temporary_statement* statement,
1026                                    Expression* expr, Location location)
1027     : Expression(EXPRESSION_SET_AND_USE_TEMPORARY, location),
1028       statement_(statement), expr_(expr)
1029   { }
1030
1031   // Return the temporary.
1032   Temporary_statement*
1033   temporary() const
1034   { return this->statement_; }
1035
1036   // Return the expression.
1037   Expression*
1038   expression() const
1039   { return this->expr_; }
1040
1041  protected:
1042   int
1043   do_traverse(Traverse* traverse)
1044   { return Expression::traverse(&this->expr_, traverse); }
1045
1046   Type*
1047   do_type();
1048
1049   void
1050   do_determine_type(const Type_context*)
1051   { }
1052
1053   Expression*
1054   do_copy()
1055   {
1056     return make_set_and_use_temporary(this->statement_, this->expr_,
1057                                       this->location());
1058   }
1059
1060   bool
1061   do_is_addressable() const
1062   { return true; }
1063
1064   void
1065   do_address_taken(bool);
1066
1067   tree
1068   do_get_tree(Translate_context*);
1069
1070   void
1071   do_dump_expression(Ast_dump_context*) const;
1072
1073  private:
1074   // The statement where the temporary variable is defined.
1075   Temporary_statement* statement_;
1076   // The expression to assign to the temporary.
1077   Expression* expr_;
1078 };
1079
1080 // A string expression.
1081
1082 class String_expression : public Expression
1083 {
1084  public:
1085   String_expression(const std::string& val, Location location)
1086     : Expression(EXPRESSION_STRING, location),
1087       val_(val), type_(NULL)
1088   { }
1089
1090   const std::string&
1091   val() const
1092   { return this->val_; }
1093
1094   static Expression*
1095   do_import(Import*);
1096
1097  protected:
1098   bool
1099   do_is_constant() const
1100   { return true; }
1101
1102   bool
1103   do_string_constant_value(std::string* val) const
1104   {
1105     *val = this->val_;
1106     return true;
1107   }
1108
1109   Type*
1110   do_type();
1111
1112   void
1113   do_determine_type(const Type_context*);
1114
1115   Expression*
1116   do_copy()
1117   { return this; }
1118
1119   tree
1120   do_get_tree(Translate_context*);
1121
1122   // Write string literal to a string dump.
1123   static void
1124   export_string(String_dump* exp, const String_expression* str);
1125
1126   void
1127   do_export(Export*) const;
1128
1129   void
1130   do_dump_expression(Ast_dump_context*) const;
1131
1132  private:
1133   // The string value.  This is immutable.
1134   const std::string val_;
1135   // The type as determined by context.
1136   Type* type_;
1137 };
1138
1139 // A binary expression.
1140
1141 class Binary_expression : public Expression
1142 {
1143  public:
1144   Binary_expression(Operator op, Expression* left, Expression* right,
1145                     Location location)
1146     : Expression(EXPRESSION_BINARY, location),
1147       op_(op), left_(left), right_(right)
1148   { }
1149
1150   // Return the operator.
1151   Operator
1152   op()
1153   { return this->op_; }
1154
1155   // Return the left hand expression.
1156   Expression*
1157   left()
1158   { return this->left_; }
1159
1160   // Return the right hand expression.
1161   Expression*
1162   right()
1163   { return this->right_; }
1164
1165   // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
1166   // Return true if this could be done, false if not.  Issue errors at
1167   // LOCATION as appropriate.
1168   static bool
1169   eval_constant(Operator op, Numeric_constant* left_nc,
1170                 Numeric_constant* right_nc, Location location,
1171                 Numeric_constant* nc);
1172
1173   // Compare constants LEFT_NC and RIGHT_NC according to OP, setting
1174   // *RESULT.  Return true if this could be done, false if not.  Issue
1175   // errors at LOCATION as appropriate.
1176   static bool
1177   compare_constant(Operator op, Numeric_constant* left_nc,
1178                    Numeric_constant* right_nc, Location location,
1179                    bool* result);
1180
1181   static Expression*
1182   do_import(Import*);
1183
1184   // Report an error if OP can not be applied to TYPE.  Return whether
1185   // it can.  OTYPE is the type of the other operand.
1186   static bool
1187   check_operator_type(Operator op, Type* type, Type* otype, Location);
1188
1189  protected:
1190   int
1191   do_traverse(Traverse* traverse);
1192
1193   Expression*
1194   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1195
1196   bool
1197   do_is_constant() const
1198   { return this->left_->is_constant() && this->right_->is_constant(); }
1199
1200   bool
1201   do_numeric_constant_value(Numeric_constant*) const;
1202
1203   void
1204   do_discarding_value();
1205
1206   Type*
1207   do_type();
1208
1209   void
1210   do_determine_type(const Type_context*);
1211
1212   void
1213   do_check_types(Gogo*);
1214
1215   Expression*
1216   do_copy()
1217   {
1218     return Expression::make_binary(this->op_, this->left_->copy(),
1219                                    this->right_->copy(), this->location());
1220   }
1221
1222   tree
1223   do_get_tree(Translate_context*);
1224
1225   void
1226   do_export(Export*) const;
1227
1228   void
1229   do_dump_expression(Ast_dump_context*) const;
1230
1231  private:
1232   static bool
1233   operation_type(Operator op, Type* left_type, Type* right_type,
1234                  Type** result_type);
1235
1236   static bool
1237   cmp_to_bool(Operator op, int cmp);
1238
1239   static bool
1240   eval_integer(Operator op, const Numeric_constant*, const Numeric_constant*,
1241                Location, Numeric_constant*);
1242
1243   static bool
1244   eval_float(Operator op, const Numeric_constant*, const Numeric_constant*,
1245              Location, Numeric_constant*);
1246
1247   static bool
1248   eval_complex(Operator op, const Numeric_constant*, const Numeric_constant*,
1249                Location, Numeric_constant*);
1250
1251   static bool
1252   compare_integer(const Numeric_constant*, const Numeric_constant*, int*);
1253
1254   static bool
1255   compare_float(const Numeric_constant*, const Numeric_constant *, int*);
1256
1257   static bool
1258   compare_complex(const Numeric_constant*, const Numeric_constant*, int*);
1259
1260   Expression*
1261   lower_struct_comparison(Gogo*, Statement_inserter*);
1262
1263   Expression*
1264   lower_array_comparison(Gogo*, Statement_inserter*);
1265
1266   Expression*
1267   lower_compare_to_memcmp(Gogo*, Statement_inserter*);
1268
1269   Expression*
1270   operand_address(Statement_inserter*, Expression*);
1271
1272   // The binary operator to apply.
1273   Operator op_;
1274   // The left hand side operand.
1275   Expression* left_;
1276   // The right hand side operand.
1277   Expression* right_;
1278 };
1279
1280 // A call expression.  The go statement needs to dig inside this.
1281
1282 class Call_expression : public Expression
1283 {
1284  public:
1285   Call_expression(Expression* fn, Expression_list* args, bool is_varargs,
1286                   Location location)
1287     : Expression(EXPRESSION_CALL, location),
1288       fn_(fn), args_(args), type_(NULL), results_(NULL), tree_(NULL),
1289       is_varargs_(is_varargs), are_hidden_fields_ok_(false),
1290       varargs_are_lowered_(false), types_are_determined_(false),
1291       is_deferred_(false), issued_error_(false)
1292   { }
1293
1294   // The function to call.
1295   Expression*
1296   fn() const
1297   { return this->fn_; }
1298
1299   // The arguments.
1300   Expression_list*
1301   args()
1302   { return this->args_; }
1303
1304   const Expression_list*
1305   args() const
1306   { return this->args_; }
1307
1308   // Get the function type.
1309   Function_type*
1310   get_function_type() const;
1311
1312   // Return the number of values this call will return.
1313   size_t
1314   result_count() const;
1315
1316   // Return the temporary variable which holds result I.  This is only
1317   // valid after the expression has been lowered, and is only valid
1318   // for calls which return multiple results.
1319   Temporary_statement*
1320   result(size_t i) const;
1321
1322   // Return whether this is a call to the predeclared function
1323   // recover.
1324   bool
1325   is_recover_call() const;
1326
1327   // Set the argument for a call to recover.
1328   void
1329   set_recover_arg(Expression*);
1330
1331   // Whether the last argument is a varargs argument (f(a...)).
1332   bool
1333   is_varargs() const
1334   { return this->is_varargs_; }
1335
1336   // Note that varargs have already been lowered.
1337   void
1338   set_varargs_are_lowered()
1339   { this->varargs_are_lowered_ = true; }
1340
1341   // Note that it is OK for this call to set hidden fields when
1342   // passing arguments.
1343   void
1344   set_hidden_fields_are_ok()
1345   { this->are_hidden_fields_ok_ = true; }
1346
1347   // Whether this call is being deferred.
1348   bool
1349   is_deferred() const
1350   { return this->is_deferred_; }
1351
1352   // Note that the call is being deferred.
1353   void
1354   set_is_deferred()
1355   { this->is_deferred_ = true; }
1356
1357   // We have found an error with this call expression; return true if
1358   // we should report it.
1359   bool
1360   issue_error();
1361
1362  protected:
1363   int
1364   do_traverse(Traverse*);
1365
1366   virtual Expression*
1367   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1368
1369   void
1370   do_discarding_value()
1371   { }
1372
1373   virtual Type*
1374   do_type();
1375
1376   virtual void
1377   do_determine_type(const Type_context*);
1378
1379   virtual void
1380   do_check_types(Gogo*);
1381
1382   Expression*
1383   do_copy()
1384   {
1385     return Expression::make_call(this->fn_->copy(),
1386                                  (this->args_ == NULL
1387                                   ? NULL
1388                                   : this->args_->copy()),
1389                                  this->is_varargs_, this->location());
1390   }
1391
1392   bool
1393   do_must_eval_in_order() const;
1394
1395   virtual tree
1396   do_get_tree(Translate_context*);
1397
1398   virtual bool
1399   do_is_recover_call() const;
1400
1401   virtual void
1402   do_set_recover_arg(Expression*);
1403
1404   // Let a builtin expression change the argument list.
1405   void
1406   set_args(Expression_list* args)
1407   { this->args_ = args; }
1408
1409   // Let a builtin expression lower varargs.
1410   void
1411   lower_varargs(Gogo*, Named_object* function, Statement_inserter* inserter,
1412                 Type* varargs_type, size_t param_count);
1413
1414   // Let a builtin expression check whether types have been
1415   // determined.
1416   bool
1417   determining_types();
1418
1419   void
1420   do_dump_expression(Ast_dump_context*) const;
1421
1422  private:
1423   bool
1424   check_argument_type(int, const Type*, const Type*, Location, bool);
1425
1426   tree
1427   interface_method_function(Translate_context*,
1428                             Interface_field_reference_expression*,
1429                             tree*);
1430
1431   tree
1432   set_results(Translate_context*, tree);
1433
1434   // The function to call.
1435   Expression* fn_;
1436   // The arguments to pass.  This may be NULL if there are no
1437   // arguments.
1438   Expression_list* args_;
1439   // The type of the expression, to avoid recomputing it.
1440   Type* type_;
1441   // The list of temporaries which will hold the results if the
1442   // function returns a tuple.
1443   std::vector<Temporary_statement*>* results_;
1444   // The tree for the call, used for a call which returns a tuple.
1445   tree tree_;
1446   // True if the last argument is a varargs argument (f(a...)).
1447   bool is_varargs_;
1448   // True if this statement may pass hidden fields in the arguments.
1449   // This is used for generated method stubs.
1450   bool are_hidden_fields_ok_;
1451   // True if varargs have already been lowered.
1452   bool varargs_are_lowered_;
1453   // True if types have been determined.
1454   bool types_are_determined_;
1455   // True if the call is an argument to a defer statement.
1456   bool is_deferred_;
1457   // True if we reported an error about a mismatch between call
1458   // results and uses.  This is to avoid producing multiple errors
1459   // when there are multiple Call_result_expressions.
1460   bool issued_error_;
1461 };
1462
1463 // An expression which represents a pointer to a function.
1464
1465 class Func_expression : public Expression
1466 {
1467  public:
1468   Func_expression(Named_object* function, Expression* closure,
1469                   Location location)
1470     : Expression(EXPRESSION_FUNC_REFERENCE, location),
1471       function_(function), closure_(closure)
1472   { }
1473
1474   // Return the object associated with the function.
1475   const Named_object*
1476   named_object() const
1477   { return this->function_; }
1478
1479   // Return the closure for this function.  This will return NULL if
1480   // the function has no closure, which is the normal case.
1481   Expression*
1482   closure()
1483   { return this->closure_; }
1484
1485   // Return a tree for this function without evaluating the closure.
1486   tree
1487   get_tree_without_closure(Gogo*);
1488
1489  protected:
1490   int
1491   do_traverse(Traverse*);
1492
1493   Type*
1494   do_type();
1495
1496   void
1497   do_determine_type(const Type_context*)
1498   {
1499     if (this->closure_ != NULL)
1500       this->closure_->determine_type_no_context();
1501   }
1502
1503   Expression*
1504   do_copy()
1505   {
1506     return Expression::make_func_reference(this->function_,
1507                                            (this->closure_ == NULL
1508                                             ? NULL
1509                                             : this->closure_->copy()),
1510                                            this->location());
1511   }
1512
1513   tree
1514   do_get_tree(Translate_context*);
1515
1516   void
1517   do_dump_expression(Ast_dump_context*) const;
1518
1519  private:
1520   // The function itself.
1521   Named_object* function_;
1522   // A closure.  This is normally NULL.  For a nested function, it may
1523   // be a heap-allocated struct holding pointers to all the variables
1524   // referenced by this function and defined in enclosing functions.
1525   Expression* closure_;
1526 };
1527
1528 // A reference to an unknown name.
1529
1530 class Unknown_expression : public Parser_expression
1531 {
1532  public:
1533   Unknown_expression(Named_object* named_object, Location location)
1534     : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE, location),
1535       named_object_(named_object), no_error_message_(false),
1536       is_composite_literal_key_(false)
1537   { }
1538
1539   // The associated named object.
1540   Named_object*
1541   named_object() const
1542   { return this->named_object_; }
1543
1544   // The name of the identifier which was unknown.
1545   const std::string&
1546   name() const;
1547
1548   // Call this to indicate that we should not give an error if this
1549   // name is never defined.  This is used to avoid knock-on errors
1550   // during an erroneous parse.
1551   void
1552   set_no_error_message()
1553   { this->no_error_message_ = true; }
1554
1555   // Note that this expression is being used as the key in a composite
1556   // literal, so it may be OK if it is not resolved.
1557   void
1558   set_is_composite_literal_key()
1559   { this->is_composite_literal_key_ = true; }
1560
1561   // Note that this expression should no longer be treated as a
1562   // composite literal key.
1563   void
1564   clear_is_composite_literal_key()
1565   { this->is_composite_literal_key_ = false; }
1566
1567  protected:
1568   Expression*
1569   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1570
1571   Expression*
1572   do_copy()
1573   { return new Unknown_expression(this->named_object_, this->location()); }
1574
1575   void
1576   do_dump_expression(Ast_dump_context*) const;
1577
1578  private:
1579   // The unknown name.
1580   Named_object* named_object_;
1581   // True if we should not give errors if this is undefined.  This is
1582   // used if there was a parse failure.
1583   bool no_error_message_;
1584   // True if this is the key in a composite literal.
1585   bool is_composite_literal_key_;
1586 };
1587
1588 // An index expression.  This is lowered to an array index, a string
1589 // index, or a map index.
1590
1591 class Index_expression : public Parser_expression
1592 {
1593  public:
1594   Index_expression(Expression* left, Expression* start, Expression* end,
1595                    Location location)
1596     : Parser_expression(EXPRESSION_INDEX, location),
1597       left_(left), start_(start), end_(end), is_lvalue_(false)
1598   { }
1599
1600   // Record that this expression is an lvalue.
1601   void
1602   set_is_lvalue()
1603   { this->is_lvalue_ = true; }
1604
1605   // Dump an index expression, i.e. an expression of the form
1606   // expr[expr] or expr[expr:expr], to a dump context.
1607   static void
1608   dump_index_expression(Ast_dump_context*, const Expression* expr,
1609                         const Expression* start, const Expression* end);
1610
1611  protected:
1612   int
1613   do_traverse(Traverse*);
1614
1615   Expression*
1616   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1617
1618   Expression*
1619   do_copy()
1620   {
1621     return new Index_expression(this->left_->copy(), this->start_->copy(),
1622                                 (this->end_ == NULL
1623                                  ? NULL
1624                                  : this->end_->copy()),
1625                                 this->location());
1626   }
1627
1628   bool
1629   do_must_eval_subexpressions_in_order(int* skip) const
1630   {
1631     *skip = 1;
1632     return true;
1633   }
1634
1635   void
1636   do_dump_expression(Ast_dump_context*) const;
1637
1638  private:
1639   // The expression being indexed.
1640   Expression* left_;
1641   // The first index.
1642   Expression* start_;
1643   // The second index.  This is NULL for an index, non-NULL for a
1644   // slice.
1645   Expression* end_;
1646   // Whether this is being used as an l-value.  We set this during the
1647   // parse because map index expressions need to know.
1648   bool is_lvalue_;
1649 };
1650
1651 // An index into a map.
1652
1653 class Map_index_expression : public Expression
1654 {
1655  public:
1656   Map_index_expression(Expression* map, Expression* index,
1657                        Location location)
1658     : Expression(EXPRESSION_MAP_INDEX, location),
1659       map_(map), index_(index), is_lvalue_(false),
1660       is_in_tuple_assignment_(false)
1661   { }
1662
1663   // Return the map.
1664   Expression*
1665   map()
1666   { return this->map_; }
1667
1668   const Expression*
1669   map() const
1670   { return this->map_; }
1671
1672   // Return the index.
1673   Expression*
1674   index()
1675   { return this->index_; }
1676
1677   const Expression*
1678   index() const
1679   { return this->index_; }
1680
1681   // Get the type of the map being indexed.
1682   Map_type*
1683   get_map_type() const;
1684
1685   // Record that this map expression is an lvalue.  The difference is
1686   // that an lvalue always inserts the key.
1687   void
1688   set_is_lvalue()
1689   { this->is_lvalue_ = true; }
1690
1691   // Return whether this map expression occurs in an assignment to a
1692   // pair of values.
1693   bool
1694   is_in_tuple_assignment() const
1695   { return this->is_in_tuple_assignment_; }
1696
1697   // Record that this map expression occurs in an assignment to a pair
1698   // of values.
1699   void
1700   set_is_in_tuple_assignment()
1701   { this->is_in_tuple_assignment_ = true; }
1702
1703   // Return a tree for the map index.  This returns a tree which
1704   // evaluates to a pointer to a value in the map.  If INSERT is true,
1705   // the key will be inserted if not present, and the value pointer
1706   // will be zero initialized.  If INSERT is false, and the key is not
1707   // present in the map, the pointer will be NULL.
1708   tree
1709   get_value_pointer(Translate_context*, bool insert);
1710
1711  protected:
1712   int
1713   do_traverse(Traverse*);
1714
1715   Type*
1716   do_type();
1717
1718   void
1719   do_determine_type(const Type_context*);
1720
1721   void
1722   do_check_types(Gogo*);
1723
1724   Expression*
1725   do_copy()
1726   {
1727     return Expression::make_map_index(this->map_->copy(),
1728                                       this->index_->copy(),
1729                                       this->location());
1730   }
1731
1732   bool
1733   do_must_eval_subexpressions_in_order(int* skip) const
1734   {
1735     *skip = 1;
1736     return true;
1737   }
1738
1739   // A map index expression is an lvalue but it is not addressable.
1740
1741   tree
1742   do_get_tree(Translate_context*);
1743
1744   void
1745   do_dump_expression(Ast_dump_context*) const;
1746
1747  private:
1748   // The map we are looking into.
1749   Expression* map_;
1750   // The index.
1751   Expression* index_;
1752   // Whether this is an lvalue.
1753   bool is_lvalue_;
1754   // Whether this is in a tuple assignment to a pair of values.
1755   bool is_in_tuple_assignment_;
1756 };
1757
1758 // An expression which represents a method bound to its first
1759 // argument.
1760
1761 class Bound_method_expression : public Expression
1762 {
1763  public:
1764   Bound_method_expression(Expression* expr, Named_object* method,
1765                           Location location)
1766     : Expression(EXPRESSION_BOUND_METHOD, location),
1767       expr_(expr), expr_type_(NULL), method_(method)
1768   { }
1769
1770   // Return the object which is the first argument.
1771   Expression*
1772   first_argument()
1773   { return this->expr_; }
1774
1775   // Return the implicit type of the first argument.  This will be
1776   // non-NULL when using a method from an anonymous field without
1777   // using an explicit stub.
1778   Type*
1779   first_argument_type() const
1780   { return this->expr_type_; }
1781
1782   // Return the method function.
1783   Named_object*
1784   method()
1785   { return this->method_; }
1786
1787   // Set the implicit type of the expression.
1788   void
1789   set_first_argument_type(Type* type)
1790   { this->expr_type_ = type; }
1791
1792  protected:
1793   int
1794   do_traverse(Traverse*);
1795
1796   Type*
1797   do_type();
1798
1799   void
1800   do_determine_type(const Type_context*);
1801
1802   void
1803   do_check_types(Gogo*);
1804
1805   Expression*
1806   do_copy()
1807   {
1808     return new Bound_method_expression(this->expr_->copy(), this->method_,
1809                                        this->location());
1810   }
1811
1812   tree
1813   do_get_tree(Translate_context*);
1814
1815   void
1816   do_dump_expression(Ast_dump_context*) const;
1817
1818  private:
1819   // The object used to find the method.  This is passed to the method
1820   // as the first argument.
1821   Expression* expr_;
1822   // The implicit type of the object to pass to the method.  This is
1823   // NULL in the normal case, non-NULL when using a method from an
1824   // anonymous field which does not require a stub.
1825   Type* expr_type_;
1826   // The method itself.
1827   Named_object* method_;
1828 };
1829
1830 // A reference to a field in a struct.
1831
1832 class Field_reference_expression : public Expression
1833 {
1834  public:
1835   Field_reference_expression(Expression* expr, unsigned int field_index,
1836                              Location location)
1837     : Expression(EXPRESSION_FIELD_REFERENCE, location),
1838       expr_(expr), field_index_(field_index)
1839   { }
1840
1841   // Return the struct expression.
1842   Expression*
1843   expr() const
1844   { return this->expr_; }
1845
1846   // Return the field index.
1847   unsigned int
1848   field_index() const
1849   { return this->field_index_; }
1850
1851   // Set the struct expression.  This is used when parsing.
1852   void
1853   set_struct_expression(Expression* expr)
1854   {
1855     go_assert(this->expr_ == NULL);
1856     this->expr_ = expr;
1857   }
1858
1859  protected:
1860   int
1861   do_traverse(Traverse* traverse)
1862   { return Expression::traverse(&this->expr_, traverse); }
1863
1864   Type*
1865   do_type();
1866
1867   void
1868   do_determine_type(const Type_context*)
1869   { this->expr_->determine_type_no_context(); }
1870
1871   void
1872   do_check_types(Gogo*);
1873
1874   Expression*
1875   do_copy()
1876   {
1877     return Expression::make_field_reference(this->expr_->copy(),
1878                                             this->field_index_,
1879                                             this->location());
1880   }
1881
1882   bool
1883   do_is_addressable() const
1884   { return this->expr_->is_addressable(); }
1885
1886   tree
1887   do_get_tree(Translate_context*);
1888
1889   void
1890   do_dump_expression(Ast_dump_context*) const;
1891
1892  private:
1893   // The expression we are looking into.  This should have a type of
1894   // struct.
1895   Expression* expr_;
1896   // The zero-based index of the field we are retrieving.
1897   unsigned int field_index_;
1898 };
1899
1900 // A reference to a field of an interface.
1901
1902 class Interface_field_reference_expression : public Expression
1903 {
1904  public:
1905   Interface_field_reference_expression(Expression* expr,
1906                                        const std::string& name,
1907                                        Location location)
1908     : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE, location),
1909       expr_(expr), name_(name)
1910   { }
1911
1912   // Return the expression for the interface object.
1913   Expression*
1914   expr()
1915   { return this->expr_; }
1916
1917   // Return the name of the method to call.
1918   const std::string&
1919   name() const
1920   { return this->name_; }
1921
1922   // Return a tree for the pointer to the function to call, given a
1923   // tree for the expression.
1924   tree
1925   get_function_tree(Translate_context*, tree);
1926
1927   // Return a tree for the first argument to pass to the interface
1928   // function, given a tree for the expression.  This is the real
1929   // object associated with the interface object.
1930   tree
1931   get_underlying_object_tree(Translate_context*, tree);
1932
1933  protected:
1934   int
1935   do_traverse(Traverse* traverse);
1936
1937   Type*
1938   do_type();
1939
1940   void
1941   do_determine_type(const Type_context*);
1942
1943   void
1944   do_check_types(Gogo*);
1945
1946   Expression*
1947   do_copy()
1948   {
1949     return Expression::make_interface_field_reference(this->expr_->copy(),
1950                                                       this->name_,
1951                                                       this->location());
1952   }
1953
1954   tree
1955   do_get_tree(Translate_context*);
1956
1957   void
1958   do_dump_expression(Ast_dump_context*) const;
1959
1960  private:
1961   // The expression for the interface object.  This should have a type
1962   // of interface or pointer to interface.
1963   Expression* expr_;
1964   // The field we are retrieving--the name of the method.
1965   std::string name_;
1966 };
1967
1968 // A type guard expression.
1969
1970 class Type_guard_expression : public Expression
1971 {
1972  public:
1973   Type_guard_expression(Expression* expr, Type* type, Location location)
1974     : Expression(EXPRESSION_TYPE_GUARD, location),
1975       expr_(expr), type_(type)
1976   { }
1977
1978   // Return the expression to convert.
1979   Expression*
1980   expr()
1981   { return this->expr_; }
1982
1983   // Return the type to which to convert.
1984   Type*
1985   type()
1986   { return this->type_; }
1987
1988  protected:
1989   int
1990   do_traverse(Traverse* traverse);
1991
1992   Type*
1993   do_type()
1994   { return this->type_; }
1995
1996   void
1997   do_determine_type(const Type_context*)
1998   { this->expr_->determine_type_no_context(); }
1999
2000   void
2001   do_check_types(Gogo*);
2002
2003   Expression*
2004   do_copy()
2005   {
2006     return new Type_guard_expression(this->expr_->copy(), this->type_,
2007                                      this->location());
2008   }
2009
2010   tree
2011   do_get_tree(Translate_context*);
2012
2013   void
2014   do_dump_expression(Ast_dump_context*) const;
2015
2016  private:
2017   // The expression to convert.
2018   Expression* expr_;
2019   // The type to which to convert.
2020   Type* type_;
2021 };
2022
2023 // A receive expression.
2024
2025 class Receive_expression : public Expression
2026 {
2027  public:
2028   Receive_expression(Expression* channel, Location location)
2029     : Expression(EXPRESSION_RECEIVE, location),
2030       channel_(channel)
2031   { }
2032
2033   // Return the channel.
2034   Expression*
2035   channel()
2036   { return this->channel_; }
2037
2038  protected:
2039   int
2040   do_traverse(Traverse* traverse)
2041   { return Expression::traverse(&this->channel_, traverse); }
2042
2043   void
2044   do_discarding_value()
2045   { }
2046
2047   Type*
2048   do_type();
2049
2050   void
2051   do_determine_type(const Type_context*)
2052   { this->channel_->determine_type_no_context(); }
2053
2054   void
2055   do_check_types(Gogo*);
2056
2057   Expression*
2058   do_copy()
2059   {
2060     return Expression::make_receive(this->channel_->copy(), this->location());
2061   }
2062
2063   bool
2064   do_must_eval_in_order() const
2065   { return true; }
2066
2067   tree
2068   do_get_tree(Translate_context*);
2069
2070   void
2071   do_dump_expression(Ast_dump_context*) const;
2072
2073  private:
2074   // The channel from which we are receiving.
2075   Expression* channel_;
2076 };
2077
2078 // A numeric constant.  This is used both for untyped constants and
2079 // for constants that have a type.
2080
2081 class Numeric_constant
2082 {
2083  public:
2084   Numeric_constant()
2085     : classification_(NC_INVALID), type_(NULL)
2086   { }
2087
2088   ~Numeric_constant();
2089
2090   Numeric_constant(const Numeric_constant&);
2091
2092   Numeric_constant& operator=(const Numeric_constant&);
2093
2094   // Set to an unsigned long value.
2095   void
2096   set_unsigned_long(Type*, unsigned long);
2097
2098   // Set to an integer value.
2099   void
2100   set_int(Type*, const mpz_t);
2101
2102   // Set to a rune value.
2103   void
2104   set_rune(Type*, const mpz_t);
2105
2106   // Set to a floating point value.
2107   void
2108   set_float(Type*, const mpfr_t);
2109
2110   // Set to a complex value.
2111   void
2112   set_complex(Type*, const mpfr_t, const mpfr_t);
2113
2114   // Classifiers.
2115   bool
2116   is_int() const
2117   { return this->classification_ == Numeric_constant::NC_INT; }
2118
2119   bool
2120   is_rune() const
2121   { return this->classification_ == Numeric_constant::NC_RUNE; }
2122
2123   bool
2124   is_float() const
2125   { return this->classification_ == Numeric_constant::NC_FLOAT; }
2126
2127   bool
2128   is_complex() const
2129   { return this->classification_ == Numeric_constant::NC_COMPLEX; }
2130
2131   // Value retrievers.  These will initialize the values as well as
2132   // set them.  GET_INT is only valid if IS_INT returns true, and
2133   // likewise respectively.
2134   void
2135   get_int(mpz_t*) const;
2136
2137   void
2138   get_rune(mpz_t*) const;
2139
2140   void
2141   get_float(mpfr_t*) const;
2142
2143   void
2144   get_complex(mpfr_t*, mpfr_t*) const;
2145
2146   // Codes returned by to_unsigned_long.
2147   enum To_unsigned_long
2148   {
2149     // Value is integer and fits in unsigned long.
2150     NC_UL_VALID,
2151     // Value is not integer.
2152     NC_UL_NOTINT,
2153     // Value is integer but is negative.
2154     NC_UL_NEGATIVE,
2155     // Value is non-negative integer but does not fit in unsigned
2156     // long.
2157     NC_UL_BIG
2158   };
2159
2160   // If the value can be expressed as an integer that fits in an
2161   // unsigned long, set *VAL and return NC_UL_VALID.  Otherwise return
2162   // one of the other To_unsigned_long codes.
2163   To_unsigned_long
2164   to_unsigned_long(unsigned long* val) const;
2165
2166   // If the value can be expressed as an int, return true and
2167   // initialize and set VAL.  This will return false for a value with
2168   // an explicit float or complex type, even if the value is integral.
2169   bool
2170   to_int(mpz_t* val) const;
2171
2172   // If the value can be expressed as a float, return true and
2173   // initialize and set VAL.
2174   bool
2175   to_float(mpfr_t* val) const;
2176
2177   // If the value can be expressed as a complex, return true and
2178   // initialize and set VR and VI.
2179   bool
2180   to_complex(mpfr_t* vr, mpfr_t* vi) const;
2181
2182   // Get the type.
2183   Type*
2184   type() const;
2185
2186   // If the constant can be expressed in TYPE, then set the type of
2187   // the constant to TYPE and return true.  Otherwise return false,
2188   // and, if ISSUE_ERROR is true, issue an error message.  LOCATION is
2189   // the location to use for the error.
2190   bool
2191   set_type(Type* type, bool issue_error, Location location);
2192
2193   // Return an Expression for this value.
2194   Expression*
2195   expression(Location) const;
2196
2197  private:
2198   void
2199   clear();
2200
2201   To_unsigned_long
2202   mpz_to_unsigned_long(const mpz_t ival, unsigned long *val) const;
2203
2204   To_unsigned_long
2205   mpfr_to_unsigned_long(const mpfr_t fval, unsigned long *val) const;
2206
2207   bool
2208   check_int_type(Integer_type*, bool, Location) const;
2209
2210   bool
2211   check_float_type(Float_type*, bool, Location) const;
2212
2213   bool
2214   check_complex_type(Complex_type*, bool, Location) const;
2215
2216   // The kinds of constants.
2217   enum Classification
2218   {
2219     NC_INVALID,
2220     NC_RUNE,
2221     NC_INT,
2222     NC_FLOAT,
2223     NC_COMPLEX
2224   };
2225
2226   // The kind of constant.
2227   Classification classification_;
2228   // The value.
2229   union
2230   {
2231     // If NC_INT or NC_RUNE.
2232     mpz_t int_val;
2233     // If NC_FLOAT.
2234     mpfr_t float_val;
2235     // If NC_COMPLEX.
2236     struct
2237     {
2238       mpfr_t real;
2239       mpfr_t imag;
2240     } complex_val;
2241   } u_;
2242   // The type if there is one.  This will be NULL for an untyped
2243   // constant.
2244   Type* type_;
2245 };
2246
2247 #endif // !defined(GO_EXPRESSIONS_H)