1 // expressions.h -- Go frontend expression handling. -*- C++ -*-
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.
7 #ifndef GO_EXPRESSIONS_H
8 #define GO_EXPRESSIONS_H
16 class Translate_context;
18 class Statement_inserter;
25 class Expression_list;
27 class Temporary_reference_expression;
28 class String_expression;
29 class Binary_expression;
30 class Call_expression;
31 class Func_expression;
32 class Unknown_expression;
33 class Index_expression;
34 class Map_index_expression;
35 class Bound_method_expression;
36 class Field_reference_expression;
37 class Interface_field_reference_expression;
38 class Type_guard_expression;
39 class Receive_expression;
43 class Temporary_statement;
45 class Ast_dump_context;
48 // The base class for all expressions.
53 // The types of expressions.
54 enum Expression_classification
60 EXPRESSION_CONST_REFERENCE,
61 EXPRESSION_VAR_REFERENCE,
62 EXPRESSION_TEMPORARY_REFERENCE,
64 EXPRESSION_FUNC_REFERENCE,
65 EXPRESSION_UNKNOWN_REFERENCE,
74 EXPRESSION_CALL_RESULT,
75 EXPRESSION_BOUND_METHOD,
77 EXPRESSION_ARRAY_INDEX,
78 EXPRESSION_STRING_INDEX,
81 EXPRESSION_FIELD_REFERENCE,
82 EXPRESSION_INTERFACE_FIELD_REFERENCE,
83 EXPRESSION_ALLOCATION,
84 EXPRESSION_TYPE_GUARD,
85 EXPRESSION_CONVERSION,
86 EXPRESSION_UNSAFE_CONVERSION,
87 EXPRESSION_STRUCT_CONSTRUCTION,
88 EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
89 EXPRESSION_OPEN_ARRAY_CONSTRUCTION,
90 EXPRESSION_MAP_CONSTRUCTION,
91 EXPRESSION_COMPOSITE_LITERAL,
92 EXPRESSION_HEAP_COMPOSITE,
94 EXPRESSION_TYPE_DESCRIPTOR,
96 EXPRESSION_STRUCT_FIELD_OFFSET,
97 EXPRESSION_MAP_DESCRIPTOR,
101 Expression(Expression_classification, source_location);
103 virtual ~Expression();
105 // Make an error expression. This is used when a parse error occurs
106 // to prevent cascading errors.
108 make_error(source_location);
110 // Make an expression which is really a type. This is used during
113 make_type(Type*, source_location);
115 // Make a unary expression.
117 make_unary(Operator, Expression*, source_location);
119 // Make a binary expression.
121 make_binary(Operator, Expression*, Expression*, source_location);
123 // Make a reference to a constant in an expression.
125 make_const_reference(Named_object*, source_location);
127 // Make a reference to a variable in an expression.
129 make_var_reference(Named_object*, source_location);
131 // Make a reference to a temporary variable. Temporary variables
132 // are always created by a single statement, which is what we use to
134 static Temporary_reference_expression*
135 make_temporary_reference(Temporary_statement*, source_location);
137 // Make a sink expression--a reference to the blank identifier _.
139 make_sink(source_location);
141 // Make a reference to a function in an expression.
143 make_func_reference(Named_object*, Expression* closure, source_location);
145 // Make a reference to an unknown name. In a correct program this
146 // will always be lowered to a real const/var/func reference.
148 make_unknown_reference(Named_object*, source_location);
150 // Make a constant bool expression.
152 make_boolean(bool val, source_location);
154 // Make a constant string expression.
156 make_string(const std::string&, source_location);
158 // Make a constant integer expression. TYPE should be NULL for an
161 make_integer(const mpz_t*, Type*, source_location);
163 // Make a constant float expression. TYPE should be NULL for an
166 make_float(const mpfr_t*, Type*, source_location);
168 // Make a constant complex expression. TYPE should be NULL for an
171 make_complex(const mpfr_t* real, const mpfr_t* imag, Type*, source_location);
173 // Make a nil expression.
175 make_nil(source_location);
177 // Make an iota expression. This is used for the predeclared
182 // Make a call expression.
183 static Call_expression*
184 make_call(Expression* func, Expression_list* args, bool is_varargs,
187 // Make a reference to a specific result of a call expression which
190 make_call_result(Call_expression*, unsigned int index);
192 // Make an expression which is a method bound to its first
194 static Bound_method_expression*
195 make_bound_method(Expression* object, Named_object* method, source_location);
197 // Make an index or slice expression. This is a parser expression
198 // which represents LEFT[START:END]. END may be NULL, meaning an
199 // index rather than a slice. At parse time we may not know the
200 // type of LEFT. After parsing this is lowered to an array index, a
201 // string index, or a map index.
203 make_index(Expression* left, Expression* start, Expression* end,
206 // Make an array index expression. END may be NULL, in which case
207 // this is an lvalue.
209 make_array_index(Expression* array, Expression* start, Expression* end,
212 // Make a string index expression. END may be NULL. This is never
215 make_string_index(Expression* string, Expression* start, Expression* end,
218 // Make a map index expression. This is an lvalue.
219 static Map_index_expression*
220 make_map_index(Expression* map, Expression* val, source_location);
222 // Make a selector. This is a parser expression which represents
223 // LEFT.NAME. At parse time we may not know the type of the left
226 make_selector(Expression* left, const std::string& name, source_location);
228 // Make a reference to a field in a struct.
229 static Field_reference_expression*
230 make_field_reference(Expression*, unsigned int field_index, source_location);
232 // Make a reference to a field of an interface, with an associated
235 make_interface_field_reference(Expression*, const std::string&,
238 // Make an allocation expression.
240 make_allocation(Type*, source_location);
242 // Make a type guard expression.
244 make_type_guard(Expression*, Type*, source_location);
246 // Make a type cast expression.
248 make_cast(Type*, Expression*, source_location);
250 // Make an unsafe type cast expression. This is only used when
251 // passing parameter to builtin functions that are part of the Go
254 make_unsafe_cast(Type*, Expression*, source_location);
256 // Make a composite literal. The DEPTH parameter is how far down we
257 // are in a list of composite literals with omitted types.
259 make_composite_literal(Type*, int depth, bool has_keys, Expression_list*,
262 // Make a struct composite literal.
264 make_struct_composite_literal(Type*, Expression_list*, source_location);
266 // Make a slice composite literal.
268 make_slice_composite_literal(Type*, Expression_list*, source_location);
270 // Take a composite literal and allocate it on the heap.
272 make_heap_composite(Expression*, source_location);
274 // Make a receive expression. VAL is NULL for a unary receive.
275 static Receive_expression*
276 make_receive(Expression* channel, source_location);
278 // Make an expression which evaluates to the address of the type
279 // descriptor for TYPE.
281 make_type_descriptor(Type* type, source_location);
283 // Make an expression which evaluates to some characteristic of a
284 // type. These are only used for type descriptors, so there is no
285 // location parameter.
288 // The size of a value of the type.
290 // The required alignment of a value of the type.
292 // The required alignment of a value of the type when used as a
293 // field in a struct.
294 TYPE_INFO_FIELD_ALIGNMENT
298 make_type_info(Type* type, Type_info);
300 // Make an expression which evaluates to the offset of a field in a
301 // struct. This is only used for type descriptors, so there is no
302 // location parameter.
304 make_struct_field_offset(Struct_type*, const Struct_field*);
306 // Make an expression which evaluates to the address of the map
307 // descriptor for TYPE.
309 make_map_descriptor(Map_type* type, source_location);
311 // Make an expression which evaluates to the address of an unnamed
314 make_label_addr(Label*, source_location);
316 // Return the expression classification.
317 Expression_classification
318 classification() const
319 { return this->classification_; }
321 // Return the location of the expression.
324 { return this->location_; }
326 // Return whether this is a constant expression.
329 { return this->do_is_constant(); }
331 // If this is not a constant expression with integral type, return
332 // false. If it is one, return true, and set VAL to the value. VAL
333 // should already be initialized. If this returns true, it sets
334 // *PTYPE to the type of the value, or NULL for an abstract type.
335 // If IOTA_IS_CONSTANT is true, then an iota expression is assumed
336 // to have its final value.
338 integer_constant_value(bool iota_is_constant, mpz_t val, Type** ptype) const;
340 // If this is not a constant expression with floating point type,
341 // return false. If it is one, return true, and set VAL to the
342 // value. VAL should already be initialized. If this returns true,
343 // it sets *PTYPE to the type of the value, or NULL for an abstract
346 float_constant_value(mpfr_t val, Type** ptype) const;
348 // If this is not a constant expression with complex type, return
349 // false. If it is one, return true, and set REAL and IMAG to the
350 // value. REAL and IMAG should already be initialized. If this
351 // return strue, it sets *PTYPE to the type of the value, or NULL
352 // for an abstract type.
354 complex_constant_value(mpfr_t real, mpfr_t imag, Type** ptype) const;
356 // If this is not a constant expression with string type, return
357 // false. If it is one, return true, and set VAL to the value.
359 string_constant_value(std::string* val) const
360 { return this->do_string_constant_value(val); }
362 // This is called if the value of this expression is being
363 // discarded. This issues warnings about computed values being
367 { this->do_discarding_value(); }
369 // Return whether this is an error expression.
371 is_error_expression() const
372 { return this->classification_ == EXPRESSION_ERROR; }
374 // Return whether this expression really represents a type.
376 is_type_expression() const
377 { return this->classification_ == EXPRESSION_TYPE; }
379 // If this is a variable reference, return the Var_expression
380 // structure. Otherwise, return NULL. This is a controlled dynamic
384 { return this->convert<Var_expression, EXPRESSION_VAR_REFERENCE>(); }
386 const Var_expression*
387 var_expression() const
388 { return this->convert<const Var_expression, EXPRESSION_VAR_REFERENCE>(); }
390 // If this is a reference to a temporary variable, return the
391 // Temporary_reference_expression. Otherwise, return NULL.
392 Temporary_reference_expression*
393 temporary_reference_expression()
395 return this->convert<Temporary_reference_expression,
396 EXPRESSION_TEMPORARY_REFERENCE>();
399 // Return whether this is a sink expression.
401 is_sink_expression() const
402 { return this->classification_ == EXPRESSION_SINK; }
404 // If this is a string expression, return the String_expression
405 // structure. Otherwise, return NULL.
408 { return this->convert<String_expression, EXPRESSION_STRING>(); }
410 // Return whether this is the expression nil.
412 is_nil_expression() const
413 { return this->classification_ == EXPRESSION_NIL; }
415 // If this is an indirection through a pointer, return the
416 // expression being pointed through. Otherwise return this.
420 // If this is a binary expression, return the Binary_expression
421 // structure. Otherwise return NULL.
424 { return this->convert<Binary_expression, EXPRESSION_BINARY>(); }
426 // If this is a call expression, return the Call_expression
427 // structure. Otherwise, return NULL. This is a controlled dynamic
431 { return this->convert<Call_expression, EXPRESSION_CALL>(); }
433 // If this is an expression which refers to a function, return the
434 // Func_expression structure. Otherwise, return NULL.
437 { return this->convert<Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
439 const Func_expression*
440 func_expression() const
441 { return this->convert<const Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
443 // If this is an expression which refers to an unknown name, return
444 // the Unknown_expression structure. Otherwise, return NULL.
447 { return this->convert<Unknown_expression, EXPRESSION_UNKNOWN_REFERENCE>(); }
449 const Unknown_expression*
450 unknown_expression() const
452 return this->convert<const Unknown_expression,
453 EXPRESSION_UNKNOWN_REFERENCE>();
456 // If this is an index expression, return the Index_expression
457 // structure. Otherwise, return NULL.
460 { return this->convert<Index_expression, EXPRESSION_INDEX>(); }
462 // If this is an expression which refers to indexing in a map,
463 // return the Map_index_expression structure. Otherwise, return
465 Map_index_expression*
466 map_index_expression()
467 { return this->convert<Map_index_expression, EXPRESSION_MAP_INDEX>(); }
469 // If this is a bound method expression, return the
470 // Bound_method_expression structure. Otherwise, return NULL.
471 Bound_method_expression*
472 bound_method_expression()
473 { return this->convert<Bound_method_expression, EXPRESSION_BOUND_METHOD>(); }
475 // If this is a reference to a field in a struct, return the
476 // Field_reference_expression structure. Otherwise, return NULL.
477 Field_reference_expression*
478 field_reference_expression()
480 return this->convert<Field_reference_expression,
481 EXPRESSION_FIELD_REFERENCE>();
484 // If this is a reference to a field in an interface, return the
485 // Interface_field_reference_expression structure. Otherwise,
487 Interface_field_reference_expression*
488 interface_field_reference_expression()
490 return this->convert<Interface_field_reference_expression,
491 EXPRESSION_INTERFACE_FIELD_REFERENCE>();
494 // If this is a type guard expression, return the
495 // Type_guard_expression structure. Otherwise, return NULL.
496 Type_guard_expression*
497 type_guard_expression()
498 { return this->convert<Type_guard_expression, EXPRESSION_TYPE_GUARD>(); }
500 // If this is a receive expression, return the Receive_expression
501 // structure. Otherwise, return NULL.
504 { return this->convert<Receive_expression, EXPRESSION_RECEIVE>(); }
506 // Return true if this is a composite literal.
508 is_composite_literal() const;
510 // Return true if this is a composite literal which is not constant.
512 is_nonconstant_composite_literal() const;
514 // Return true if this is a reference to a local variable.
516 is_local_variable() const;
518 // Traverse an expression.
520 traverse(Expression**, Traverse*);
522 // Traverse subexpressions of this expression.
524 traverse_subexpressions(Traverse*);
526 // Lower an expression. This is called immediately after parsing.
527 // FUNCTION is the function we are in; it will be NULL for an
528 // expression initializing a global variable. INSERTER may be used
529 // to insert statements before the statement or initializer
530 // containing this expression; it is normally used to create
531 // temporary variables. IOTA_VALUE is the value that we should give
532 // to any iota expressions. This function must resolve expressions
533 // which could not be fully parsed into their final form. It
534 // returns the same Expression or a new one.
536 lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter,
538 { return this->do_lower(gogo, function, inserter, iota_value); }
540 // Determine the real type of an expression with abstract integer,
541 // floating point, or complex type. TYPE_CONTEXT describes the
544 determine_type(const Type_context*);
546 // Check types in an expression.
548 check_types(Gogo* gogo)
549 { this->do_check_types(gogo); }
551 // Determine the type when there is no context.
553 determine_type_no_context();
555 // Return the current type of the expression. This may be changed
556 // by determine_type.
559 { return this->do_type(); }
561 // Return a copy of an expression.
564 { return this->do_copy(); }
566 // Return whether the expression is addressable--something which may
567 // be used as the operand of the unary & operator.
569 is_addressable() const
570 { return this->do_is_addressable(); }
572 // Note that we are taking the address of this expression. ESCAPES
573 // is true if this address escapes the current function.
575 address_taken(bool escapes)
576 { this->do_address_taken(escapes); }
578 // Return whether this expression must be evaluated in order
579 // according to the order of evaluation rules. This is basically
580 // true of all expressions with side-effects.
582 must_eval_in_order() const
583 { return this->do_must_eval_in_order(); }
585 // Return whether subexpressions of this expression must be
586 // evaluated in order. This is true of index expressions and
587 // pointer indirections. This sets *SKIP to the number of
588 // subexpressions to skip during traversing, as index expressions
589 // only requiring moving the index, not the array.
591 must_eval_subexpressions_in_order(int* skip) const
594 return this->do_must_eval_subexpressions_in_order(skip);
597 // Return the tree for this expression.
599 get_tree(Translate_context*);
601 // Return a tree handling any conversions which must be done during
604 convert_for_assignment(Translate_context*, Type* lhs_type, Type* rhs_type,
605 tree rhs_tree, source_location location);
607 // Return a tree converting a value of one interface type to another
608 // interface type. If FOR_TYPE_GUARD is true this is for a type
611 convert_interface_to_interface(Translate_context*, Type* lhs_type,
612 Type* rhs_type, tree rhs_tree,
613 bool for_type_guard, source_location);
615 // Return a tree implementing the comparison LHS_TREE OP RHS_TREE.
616 // TYPE is the type of both sides.
618 comparison_tree(Translate_context*, Operator op, Type* left_type,
619 tree left_tree, Type* right_type, tree right_tree,
622 // Return a tree for the multi-precision integer VAL in TYPE.
624 integer_constant_tree(mpz_t val, tree type);
626 // Return a tree for the floating point value VAL in TYPE.
628 float_constant_tree(mpfr_t val, tree type);
630 // Return a tree for the complex value REAL/IMAG in TYPE.
632 complex_constant_tree(mpfr_t real, mpfr_t imag, tree type);
634 // Export the expression. This is only used for constants. It will
635 // be used for things like values of named constants and sizes of
638 export_expression(Export* exp) const
639 { this->do_export(exp); }
641 // Import an expression.
643 import_expression(Import*);
645 // Return a tree which checks that VAL, of arbitrary integer type,
646 // is non-negative and is not more than the maximum value of
647 // BOUND_TYPE. If SOFAR is not NULL, it is or'red into the result.
648 // The return value may be NULL if SOFAR is NULL.
650 check_bounds(tree val, tree bound_type, tree sofar, source_location);
652 // Dump an expression to a dump constext.
654 dump_expression(Ast_dump_context*) const;
657 // May be implemented by child class: traverse the expressions.
659 do_traverse(Traverse*);
661 // Return a lowered expression.
663 do_lower(Gogo*, Named_object*, Statement_inserter*, int)
666 // Return whether this is a constant expression.
668 do_is_constant() const
671 // Return whether this is a constant expression of integral type,
672 // and set VAL to the value.
674 do_integer_constant_value(bool, mpz_t, Type**) const
677 // Return whether this is a constant expression of floating point
678 // type, and set VAL to the value.
680 do_float_constant_value(mpfr_t, Type**) const
683 // Return whether this is a constant expression of complex type, and
684 // set REAL and IMAGE to the value.
686 do_complex_constant_value(mpfr_t, mpfr_t, Type**) const
689 // Return whether this is a constant expression of string type, and
690 // set VAL to the value.
692 do_string_constant_value(std::string*) const
695 // Called by the parser if the value is being discarded.
697 do_discarding_value();
699 // Child class holds type.
703 // Child class implements determining type information.
705 do_determine_type(const Type_context*) = 0;
707 // Child class implements type checking if needed.
709 do_check_types(Gogo*)
712 // Child class implements copying.
716 // Child class implements whether the expression is addressable.
718 do_is_addressable() const
721 // Child class implements taking the address of an expression.
723 do_address_taken(bool)
726 // Child class implements whether this expression must be evaluated
729 do_must_eval_in_order() const
732 // Child class implements whether this expressions requires that
733 // subexpressions be evaluated in order. The child implementation
734 // may set *SKIP if it should be non-zero.
736 do_must_eval_subexpressions_in_order(int* /* skip */) const
739 // Child class implements conversion to tree.
741 do_get_tree(Translate_context*) = 0;
743 // Child class implements export.
745 do_export(Export*) const;
747 // For children to call to give an error for an unused value.
749 unused_value_error();
751 // For children to call when they detect that they are in error.
755 // For children to call to report an error conveniently.
757 report_error(const char*);
759 // Child class implements dumping to a dump context.
761 do_dump_expression(Ast_dump_context*) const = 0;
764 // Convert to the desired statement classification, or return NULL.
765 // This is a controlled dynamic cast.
766 template<typename Expression_class,
767 Expression_classification expr_classification>
771 return (this->classification_ == expr_classification
772 ? static_cast<Expression_class*>(this)
776 template<typename Expression_class,
777 Expression_classification expr_classification>
778 const Expression_class*
781 return (this->classification_ == expr_classification
782 ? static_cast<const Expression_class*>(this)
787 convert_type_to_interface(Translate_context*, Type*, Type*, tree,
791 get_interface_type_descriptor(Translate_context*, Type*, tree,
795 convert_interface_to_type(Translate_context*, Type*, Type*, tree,
798 // The expression classification.
799 Expression_classification classification_;
800 // The location in the input file.
801 source_location location_;
804 // A list of Expressions.
806 class Expression_list
813 // Return whether the list is empty.
816 { return this->entries_.empty(); }
818 // Return the number of entries in the list.
821 { return this->entries_.size(); }
823 // Add an entry to the end of the list.
825 push_back(Expression* expr)
826 { this->entries_.push_back(expr); }
829 append(Expression_list* add)
830 { this->entries_.insert(this->entries_.end(), add->begin(), add->end()); }
832 // Reserve space in the list.
835 { this->entries_.reserve(size); }
837 // Traverse the expressions in the list.
845 // Return true if the list contains an error expression.
847 contains_error() const;
849 // Return the first and last elements.
852 { return this->entries_.front(); }
856 { return this->entries_.front(); }
860 { return this->entries_.back(); }
864 { return this->entries_.back(); }
868 typedef std::vector<Expression*>::iterator iterator;
869 typedef std::vector<Expression*>::const_iterator const_iterator;
873 { return this->entries_.begin(); }
877 { return this->entries_.begin(); }
881 { return this->entries_.end(); }
885 { return this->entries_.end(); }
890 { this->entries_.erase(p); }
893 std::vector<Expression*> entries_;
896 // An abstract base class for an expression which is only used by the
897 // parser, and is lowered in the lowering pass.
899 class Parser_expression : public Expression
902 Parser_expression(Expression_classification classification,
903 source_location location)
904 : Expression(classification, location)
909 do_lower(Gogo*, Named_object*, Statement_inserter*, int) = 0;
915 do_determine_type(const Type_context*)
916 { go_unreachable(); }
919 do_check_types(Gogo*)
920 { go_unreachable(); }
923 do_get_tree(Translate_context*)
924 { go_unreachable(); }
927 // An expression which is simply a variable.
929 class Var_expression : public Expression
932 Var_expression(Named_object* variable, source_location location)
933 : Expression(EXPRESSION_VAR_REFERENCE, location),
937 // Return the variable.
940 { return this->variable_; }
944 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
950 do_determine_type(const Type_context*);
957 do_is_addressable() const
961 do_address_taken(bool);
964 do_get_tree(Translate_context*);
967 do_dump_expression(Ast_dump_context*) const;
970 // The variable we are referencing.
971 Named_object* variable_;
974 // A reference to a temporary variable.
976 class Temporary_reference_expression : public Expression
979 Temporary_reference_expression(Temporary_statement* statement,
980 source_location location)
981 : Expression(EXPRESSION_TEMPORARY_REFERENCE, location),
982 statement_(statement), is_lvalue_(false)
985 // Indicate that this reference appears on the left hand side of an
986 // assignment statement.
989 { this->is_lvalue_ = true; }
996 do_determine_type(const Type_context*)
1001 { return make_temporary_reference(this->statement_, this->location()); }
1004 do_is_addressable() const
1008 do_address_taken(bool);
1011 do_get_tree(Translate_context*);
1014 do_dump_expression(Ast_dump_context*) const;
1017 // The statement where the temporary variable is defined.
1018 Temporary_statement* statement_;
1019 // Whether this reference appears on the left hand side of an
1020 // assignment statement.
1024 // A string expression.
1026 class String_expression : public Expression
1029 String_expression(const std::string& val, source_location location)
1030 : Expression(EXPRESSION_STRING, location),
1031 val_(val), type_(NULL)
1036 { return this->val_; }
1043 do_is_constant() const
1047 do_string_constant_value(std::string* val) const
1057 do_determine_type(const Type_context*);
1064 do_get_tree(Translate_context*);
1066 // Write string literal to a string dump.
1068 export_string(String_dump* exp, const String_expression* str);
1071 do_export(Export*) const;
1074 do_dump_expression(Ast_dump_context*) const;
1077 // The string value. This is immutable.
1078 const std::string val_;
1079 // The type as determined by context.
1083 // A binary expression.
1085 class Binary_expression : public Expression
1088 Binary_expression(Operator op, Expression* left, Expression* right,
1089 source_location location)
1090 : Expression(EXPRESSION_BINARY, location),
1091 op_(op), left_(left), right_(right)
1094 // Return the operator.
1097 { return this->op_; }
1099 // Return the left hand expression.
1102 { return this->left_; }
1104 // Return the right hand expression.
1107 { return this->right_; }
1109 // Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
1110 // LEFT_TYPE is the type of LEFT_VAL, RIGHT_TYPE is the type of
1111 // RIGHT_VAL; LEFT_TYPE and/or RIGHT_TYPE may be NULL. Return true
1112 // if this could be done, false if not.
1114 eval_integer(Operator op, Type* left_type, mpz_t left_val,
1115 Type* right_type, mpz_t right_val, source_location,
1118 // Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
1119 // Return true if this could be done, false if not.
1121 eval_float(Operator op, Type* left_type, mpfr_t left_val,
1122 Type* right_type, mpfr_t right_val, mpfr_t val,
1125 // Apply binary opcode OP to LEFT_REAL/LEFT_IMAG and
1126 // RIGHT_REAL/RIGHT_IMAG, setting REAL/IMAG. Return true if this
1127 // could be done, false if not.
1129 eval_complex(Operator op, Type* left_type, mpfr_t left_real,
1130 mpfr_t left_imag, Type* right_type, mpfr_t right_real,
1131 mpfr_t right_imag, mpfr_t real, mpfr_t imag, source_location);
1133 // Compare integer constants according to OP.
1135 compare_integer(Operator op, mpz_t left_val, mpz_t right_val);
1137 // Compare floating point constants according to OP.
1139 compare_float(Operator op, Type* type, mpfr_t left_val, mpfr_t right_val);
1141 // Compare complex constants according to OP.
1143 compare_complex(Operator op, Type* type, mpfr_t left_real, mpfr_t left_imag,
1144 mpfr_t right_val, mpfr_t right_imag);
1149 // Report an error if OP can not be applied to TYPE. Return whether
1152 check_operator_type(Operator op, Type* type, source_location);
1156 do_traverse(Traverse* traverse);
1159 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1162 do_is_constant() const
1163 { return this->left_->is_constant() && this->right_->is_constant(); }
1166 do_integer_constant_value(bool, mpz_t val, Type**) const;
1169 do_float_constant_value(mpfr_t val, Type**) const;
1172 do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
1175 do_discarding_value();
1181 do_determine_type(const Type_context*);
1184 do_check_types(Gogo*);
1189 return Expression::make_binary(this->op_, this->left_->copy(),
1190 this->right_->copy(), this->location());
1194 do_get_tree(Translate_context*);
1197 do_export(Export*) const;
1200 do_dump_expression(Ast_dump_context*) const;
1203 // The binary operator to apply.
1205 // The left hand side operand.
1207 // The right hand side operand.
1211 // A call expression. The go statement needs to dig inside this.
1213 class Call_expression : public Expression
1216 Call_expression(Expression* fn, Expression_list* args, bool is_varargs,
1217 source_location location)
1218 : Expression(EXPRESSION_CALL, location),
1219 fn_(fn), args_(args), type_(NULL), results_(NULL), tree_(NULL),
1220 is_varargs_(is_varargs), are_hidden_fields_ok_(false),
1221 varargs_are_lowered_(false), types_are_determined_(false),
1222 is_deferred_(false), issued_error_(false)
1225 // The function to call.
1228 { return this->fn_; }
1233 { return this->args_; }
1235 const Expression_list*
1237 { return this->args_; }
1239 // Get the function type.
1241 get_function_type() const;
1243 // Return the number of values this call will return.
1245 result_count() const;
1247 // Return the temporary variable which holds result I. This is only
1248 // valid after the expression has been lowered, and is only valid
1249 // for calls which return multiple results.
1250 Temporary_statement*
1251 result(size_t i) const;
1253 // Return whether this is a call to the predeclared function
1256 is_recover_call() const;
1258 // Set the argument for a call to recover.
1260 set_recover_arg(Expression*);
1262 // Whether the last argument is a varargs argument (f(a...)).
1265 { return this->is_varargs_; }
1267 // Note that varargs have already been lowered.
1269 set_varargs_are_lowered()
1270 { this->varargs_are_lowered_ = true; }
1272 // Note that it is OK for this call to set hidden fields when
1273 // passing arguments.
1275 set_hidden_fields_are_ok()
1276 { this->are_hidden_fields_ok_ = true; }
1278 // Whether this call is being deferred.
1281 { return this->is_deferred_; }
1283 // Note that the call is being deferred.
1286 { this->is_deferred_ = true; }
1288 // We have found an error with this call expression; return true if
1289 // we should report it.
1295 do_traverse(Traverse*);
1298 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1301 do_discarding_value()
1308 do_determine_type(const Type_context*);
1311 do_check_types(Gogo*);
1316 return Expression::make_call(this->fn_->copy(),
1317 (this->args_ == NULL
1319 : this->args_->copy()),
1320 this->is_varargs_, this->location());
1324 do_must_eval_in_order() const;
1327 do_get_tree(Translate_context*);
1330 do_is_recover_call() const;
1333 do_set_recover_arg(Expression*);
1335 // Let a builtin expression change the argument list.
1337 set_args(Expression_list* args)
1338 { this->args_ = args; }
1340 // Let a builtin expression lower varargs.
1342 lower_varargs(Gogo*, Named_object* function, Statement_inserter* inserter,
1343 Type* varargs_type, size_t param_count);
1345 // Let a builtin expression check whether types have been
1348 determining_types();
1351 do_dump_expression(Ast_dump_context*) const;
1355 check_argument_type(int, const Type*, const Type*, source_location, bool);
1358 interface_method_function(Translate_context*,
1359 Interface_field_reference_expression*,
1363 set_results(Translate_context*, tree);
1365 // The function to call.
1367 // The arguments to pass. This may be NULL if there are no
1369 Expression_list* args_;
1370 // The type of the expression, to avoid recomputing it.
1372 // The list of temporaries which will hold the results if the
1373 // function returns a tuple.
1374 std::vector<Temporary_statement*>* results_;
1375 // The tree for the call, used for a call which returns a tuple.
1377 // True if the last argument is a varargs argument (f(a...)).
1379 // True if this statement may pass hidden fields in the arguments.
1380 // This is used for generated method stubs.
1381 bool are_hidden_fields_ok_;
1382 // True if varargs have already been lowered.
1383 bool varargs_are_lowered_;
1384 // True if types have been determined.
1385 bool types_are_determined_;
1386 // True if the call is an argument to a defer statement.
1388 // True if we reported an error about a mismatch between call
1389 // results and uses. This is to avoid producing multiple errors
1390 // when there are multiple Call_result_expressions.
1394 // An expression which represents a pointer to a function.
1396 class Func_expression : public Expression
1399 Func_expression(Named_object* function, Expression* closure,
1400 source_location location)
1401 : Expression(EXPRESSION_FUNC_REFERENCE, location),
1402 function_(function), closure_(closure)
1405 // Return the object associated with the function.
1407 named_object() const
1408 { return this->function_; }
1410 // Return the closure for this function. This will return NULL if
1411 // the function has no closure, which is the normal case.
1414 { return this->closure_; }
1416 // Return a tree for this function without evaluating the closure.
1418 get_tree_without_closure(Gogo*);
1422 do_traverse(Traverse*);
1428 do_determine_type(const Type_context*)
1430 if (this->closure_ != NULL)
1431 this->closure_->determine_type_no_context();
1437 return Expression::make_func_reference(this->function_,
1438 (this->closure_ == NULL
1440 : this->closure_->copy()),
1445 do_get_tree(Translate_context*);
1448 do_dump_expression(Ast_dump_context*) const;
1451 // The function itself.
1452 Named_object* function_;
1453 // A closure. This is normally NULL. For a nested function, it may
1454 // be a heap-allocated struct holding pointers to all the variables
1455 // referenced by this function and defined in enclosing functions.
1456 Expression* closure_;
1459 // A reference to an unknown name.
1461 class Unknown_expression : public Parser_expression
1464 Unknown_expression(Named_object* named_object, source_location location)
1465 : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE, location),
1466 named_object_(named_object), is_composite_literal_key_(false)
1469 // The associated named object.
1471 named_object() const
1472 { return this->named_object_; }
1474 // The name of the identifier which was unknown.
1478 // Note that this expression is being used as the key in a composite
1479 // literal, so it may be OK if it is not resolved.
1481 set_is_composite_literal_key()
1482 { this->is_composite_literal_key_ = true; }
1484 // Note that this expression should no longer be treated as a
1485 // composite literal key.
1487 clear_is_composite_literal_key()
1488 { this->is_composite_literal_key_ = false; }
1492 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1496 { return new Unknown_expression(this->named_object_, this->location()); }
1499 do_dump_expression(Ast_dump_context*) const;
1502 // The unknown name.
1503 Named_object* named_object_;
1504 // True if this is the key in a composite literal.
1505 bool is_composite_literal_key_;
1508 // An index expression. This is lowered to an array index, a string
1509 // index, or a map index.
1511 class Index_expression : public Parser_expression
1514 Index_expression(Expression* left, Expression* start, Expression* end,
1515 source_location location)
1516 : Parser_expression(EXPRESSION_INDEX, location),
1517 left_(left), start_(start), end_(end), is_lvalue_(false)
1520 // Record that this expression is an lvalue.
1523 { this->is_lvalue_ = true; }
1525 // Dump an index expression, i.e. an expression of the form
1526 // expr[expr] or expr[expr:expr], to a dump context.
1528 dump_index_expression(Ast_dump_context*, const Expression* expr,
1529 const Expression* start, const Expression* end);
1533 do_traverse(Traverse*);
1536 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1541 return new Index_expression(this->left_->copy(), this->start_->copy(),
1544 : this->end_->copy()),
1549 do_must_eval_subexpressions_in_order(int* skip) const
1556 do_dump_expression(Ast_dump_context*) const;
1559 // The expression being indexed.
1563 // The second index. This is NULL for an index, non-NULL for a
1566 // Whether this is being used as an l-value. We set this during the
1567 // parse because map index expressions need to know.
1571 // An index into a map.
1573 class Map_index_expression : public Expression
1576 Map_index_expression(Expression* map, Expression* index,
1577 source_location location)
1578 : Expression(EXPRESSION_MAP_INDEX, location),
1579 map_(map), index_(index), is_lvalue_(false),
1580 is_in_tuple_assignment_(false)
1586 { return this->map_; }
1590 { return this->map_; }
1592 // Return the index.
1595 { return this->index_; }
1599 { return this->index_; }
1601 // Get the type of the map being indexed.
1603 get_map_type() const;
1605 // Record that this map expression is an lvalue. The difference is
1606 // that an lvalue always inserts the key.
1609 { this->is_lvalue_ = true; }
1611 // Return whether this map expression occurs in an assignment to a
1614 is_in_tuple_assignment() const
1615 { return this->is_in_tuple_assignment_; }
1617 // Record that this map expression occurs in an assignment to a pair
1620 set_is_in_tuple_assignment()
1621 { this->is_in_tuple_assignment_ = true; }
1623 // Return a tree for the map index. This returns a tree which
1624 // evaluates to a pointer to a value in the map. If INSERT is true,
1625 // the key will be inserted if not present, and the value pointer
1626 // will be zero initialized. If INSERT is false, and the key is not
1627 // present in the map, the pointer will be NULL.
1629 get_value_pointer(Translate_context*, bool insert);
1633 do_traverse(Traverse*);
1639 do_determine_type(const Type_context*);
1642 do_check_types(Gogo*);
1647 return Expression::make_map_index(this->map_->copy(),
1648 this->index_->copy(),
1653 do_must_eval_subexpressions_in_order(int* skip) const
1659 // A map index expression is an lvalue but it is not addressable.
1662 do_get_tree(Translate_context*);
1665 do_dump_expression(Ast_dump_context*) const;
1668 // The map we are looking into.
1672 // Whether this is an lvalue.
1674 // Whether this is in a tuple assignment to a pair of values.
1675 bool is_in_tuple_assignment_;
1678 // An expression which represents a method bound to its first
1681 class Bound_method_expression : public Expression
1684 Bound_method_expression(Expression* expr, Named_object* method,
1685 source_location location)
1686 : Expression(EXPRESSION_BOUND_METHOD, location),
1687 expr_(expr), expr_type_(NULL), method_(method)
1690 // Return the object which is the first argument.
1693 { return this->expr_; }
1695 // Return the implicit type of the first argument. This will be
1696 // non-NULL when using a method from an anonymous field without
1697 // using an explicit stub.
1699 first_argument_type() const
1700 { return this->expr_type_; }
1702 // Return the method function.
1705 { return this->method_; }
1707 // Set the implicit type of the expression.
1709 set_first_argument_type(Type* type)
1710 { this->expr_type_ = type; }
1714 do_traverse(Traverse*);
1720 do_determine_type(const Type_context*);
1723 do_check_types(Gogo*);
1728 return new Bound_method_expression(this->expr_->copy(), this->method_,
1733 do_get_tree(Translate_context*);
1736 do_dump_expression(Ast_dump_context*) const;
1739 // The object used to find the method. This is passed to the method
1740 // as the first argument.
1742 // The implicit type of the object to pass to the method. This is
1743 // NULL in the normal case, non-NULL when using a method from an
1744 // anonymous field which does not require a stub.
1746 // The method itself.
1747 Named_object* method_;
1750 // A reference to a field in a struct.
1752 class Field_reference_expression : public Expression
1755 Field_reference_expression(Expression* expr, unsigned int field_index,
1756 source_location location)
1757 : Expression(EXPRESSION_FIELD_REFERENCE, location),
1758 expr_(expr), field_index_(field_index)
1761 // Return the struct expression.
1764 { return this->expr_; }
1766 // Return the field index.
1769 { return this->field_index_; }
1771 // Set the struct expression. This is used when parsing.
1773 set_struct_expression(Expression* expr)
1775 go_assert(this->expr_ == NULL);
1781 do_traverse(Traverse* traverse)
1782 { return Expression::traverse(&this->expr_, traverse); }
1788 do_determine_type(const Type_context*)
1789 { this->expr_->determine_type_no_context(); }
1792 do_check_types(Gogo*);
1797 return Expression::make_field_reference(this->expr_->copy(),
1803 do_is_addressable() const
1804 { return this->expr_->is_addressable(); }
1807 do_get_tree(Translate_context*);
1810 do_dump_expression(Ast_dump_context*) const;
1813 // The expression we are looking into. This should have a type of
1816 // The zero-based index of the field we are retrieving.
1817 unsigned int field_index_;
1820 // A reference to a field of an interface.
1822 class Interface_field_reference_expression : public Expression
1825 Interface_field_reference_expression(Expression* expr,
1826 const std::string& name,
1827 source_location location)
1828 : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE, location),
1829 expr_(expr), name_(name)
1832 // Return the expression for the interface object.
1835 { return this->expr_; }
1837 // Return the name of the method to call.
1840 { return this->name_; }
1842 // Return a tree for the pointer to the function to call, given a
1843 // tree for the expression.
1845 get_function_tree(Translate_context*, tree);
1847 // Return a tree for the first argument to pass to the interface
1848 // function, given a tree for the expression. This is the real
1849 // object associated with the interface object.
1851 get_underlying_object_tree(Translate_context*, tree);
1855 do_traverse(Traverse* traverse);
1861 do_determine_type(const Type_context*);
1864 do_check_types(Gogo*);
1869 return Expression::make_interface_field_reference(this->expr_->copy(),
1875 do_get_tree(Translate_context*);
1878 do_dump_expression(Ast_dump_context*) const;
1881 // The expression for the interface object. This should have a type
1882 // of interface or pointer to interface.
1884 // The field we are retrieving--the name of the method.
1888 // A type guard expression.
1890 class Type_guard_expression : public Expression
1893 Type_guard_expression(Expression* expr, Type* type, source_location location)
1894 : Expression(EXPRESSION_TYPE_GUARD, location),
1895 expr_(expr), type_(type)
1898 // Return the expression to convert.
1901 { return this->expr_; }
1903 // Return the type to which to convert.
1906 { return this->type_; }
1910 do_traverse(Traverse* traverse);
1914 { return this->type_; }
1917 do_determine_type(const Type_context*)
1918 { this->expr_->determine_type_no_context(); }
1921 do_check_types(Gogo*);
1926 return new Type_guard_expression(this->expr_->copy(), this->type_,
1931 do_get_tree(Translate_context*);
1934 do_dump_expression(Ast_dump_context*) const;
1937 // The expression to convert.
1939 // The type to which to convert.
1943 // A receive expression.
1945 class Receive_expression : public Expression
1948 Receive_expression(Expression* channel, source_location location)
1949 : Expression(EXPRESSION_RECEIVE, location),
1950 channel_(channel), for_select_(false)
1953 // Return the channel.
1956 { return this->channel_; }
1958 // Note that this is for a select statement.
1961 { this->for_select_ = true; }
1965 do_traverse(Traverse* traverse)
1966 { return Expression::traverse(&this->channel_, traverse); }
1969 do_discarding_value()
1976 do_determine_type(const Type_context*)
1977 { this->channel_->determine_type_no_context(); }
1980 do_check_types(Gogo*);
1985 return Expression::make_receive(this->channel_->copy(), this->location());
1989 do_must_eval_in_order() const
1993 do_get_tree(Translate_context*);
1996 do_dump_expression(Ast_dump_context*) const;
1999 // The channel from which we are receiving.
2000 Expression* channel_;
2001 // Whether this is for a select statement.
2005 #endif // !defined(GO_EXPRESSIONS_H)