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;
28 class Expression_list;
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;
48 class Temporary_statement;
50 class Ast_dump_context;
53 // The base class for all expressions.
58 // The types of expressions.
59 enum Expression_classification
65 EXPRESSION_CONST_REFERENCE,
66 EXPRESSION_VAR_REFERENCE,
67 EXPRESSION_TEMPORARY_REFERENCE,
68 EXPRESSION_SET_AND_USE_TEMPORARY,
70 EXPRESSION_FUNC_REFERENCE,
71 EXPRESSION_UNKNOWN_REFERENCE,
80 EXPRESSION_CALL_RESULT,
81 EXPRESSION_BOUND_METHOD,
83 EXPRESSION_ARRAY_INDEX,
84 EXPRESSION_STRING_INDEX,
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,
100 EXPRESSION_TYPE_DESCRIPTOR,
101 EXPRESSION_TYPE_INFO,
102 EXPRESSION_STRUCT_FIELD_OFFSET,
103 EXPRESSION_MAP_DESCRIPTOR,
104 EXPRESSION_LABEL_ADDR
107 Expression(Expression_classification, Location);
109 virtual ~Expression();
111 // Make an error expression. This is used when a parse error occurs
112 // to prevent cascading errors.
114 make_error(Location);
116 // Make an expression which is really a type. This is used during
119 make_type(Type*, Location);
121 // Make a unary expression.
123 make_unary(Operator, Expression*, Location);
125 // Make a binary expression.
127 make_binary(Operator, Expression*, Expression*, Location);
129 // Make a reference to a constant in an expression.
131 make_const_reference(Named_object*, Location);
133 // Make a reference to a variable in an expression.
135 make_var_reference(Named_object*, Location);
137 // Make a reference to a temporary variable. Temporary variables
138 // are always created by a single statement, which is what we use to
140 static Temporary_reference_expression*
141 make_temporary_reference(Temporary_statement*, Location);
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
147 static Set_and_use_temporary_expression*
148 make_set_and_use_temporary(Temporary_statement*, Expression*, Location);
150 // Make a sink expression--a reference to the blank identifier _.
154 // Make a reference to a function in an expression.
156 make_func_reference(Named_object*, Expression* closure, Location);
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);
163 // Make a constant bool expression.
165 make_boolean(bool val, Location);
167 // Make a constant string expression.
169 make_string(const std::string&, Location);
171 // Make a character constant expression. TYPE should be NULL for an
174 make_character(const mpz_t*, Type*, Location);
176 // Make a constant integer expression. TYPE should be NULL for an
179 make_integer(const mpz_t*, Type*, Location);
181 // Make a constant float expression. TYPE should be NULL for an
184 make_float(const mpfr_t*, Type*, Location);
186 // Make a constant complex expression. TYPE should be NULL for an
189 make_complex(const mpfr_t* real, const mpfr_t* imag, Type*, Location);
191 // Make a nil expression.
195 // Make an iota expression. This is used for the predeclared
200 // Make a call expression.
201 static Call_expression*
202 make_call(Expression* func, Expression_list* args, bool is_varargs,
205 // Make a reference to a specific result of a call expression which
208 make_call_result(Call_expression*, unsigned int index);
210 // Make an expression which is a method bound to its first
212 static Bound_method_expression*
213 make_bound_method(Expression* object, Named_object* method, Location);
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.
221 make_index(Expression* left, Expression* start, Expression* end,
224 // Make an array index expression. END may be NULL, in which case
225 // this is an lvalue.
227 make_array_index(Expression* array, Expression* start, Expression* end,
230 // Make a string index expression. END may be NULL. This is never
233 make_string_index(Expression* string, Expression* start, Expression* end,
236 // Make a map index expression. This is an lvalue.
237 static Map_index_expression*
238 make_map_index(Expression* map, Expression* val, Location);
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
244 make_selector(Expression* left, const std::string& name, Location);
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);
250 // Make a reference to a field of an interface, with an associated
253 make_interface_field_reference(Expression*, const std::string&,
256 // Make an allocation expression.
258 make_allocation(Type*, Location);
260 // Make a type guard expression.
262 make_type_guard(Expression*, Type*, Location);
264 // Make a type cast expression.
266 make_cast(Type*, Expression*, Location);
268 // Make an unsafe type cast expression. This is only used when
269 // passing parameter to builtin functions that are part of the Go
272 make_unsafe_cast(Type*, Expression*, Location);
274 // Make a composite literal. The DEPTH parameter is how far down we
275 // are in a list of composite literals with omitted types.
277 make_composite_literal(Type*, int depth, bool has_keys, Expression_list*,
280 // Make a struct composite literal.
282 make_struct_composite_literal(Type*, Expression_list*, Location);
284 // Make a slice composite literal.
286 make_slice_composite_literal(Type*, Expression_list*, Location);
288 // Take a composite literal and allocate it on the heap.
290 make_heap_composite(Expression*, Location);
292 // Make a receive expression. VAL is NULL for a unary receive.
293 static Receive_expression*
294 make_receive(Expression* channel, Location);
296 // Make an expression which evaluates to the address of the type
297 // descriptor for TYPE.
299 make_type_descriptor(Type* type, Location);
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.
306 // The size of a value of the type.
308 // The required alignment of a value of the type.
310 // The required alignment of a value of the type when used as a
311 // field in a struct.
312 TYPE_INFO_FIELD_ALIGNMENT
316 make_type_info(Type* type, Type_info);
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.
322 make_struct_field_offset(Struct_type*, const Struct_field*);
324 // Make an expression which evaluates to the address of the map
325 // descriptor for TYPE.
327 make_map_descriptor(Map_type* type, Location);
329 // Make an expression which evaluates to the address of an unnamed
332 make_label_addr(Label*, Location);
334 // Return the expression classification.
335 Expression_classification
336 classification() const
337 { return this->classification_; }
339 // Return the location of the expression.
342 { return this->location_; }
344 // Return whether this is a constant expression.
347 { return this->do_is_constant(); }
349 // If this is not a numeric constant, return false. If it is one,
350 // return true, and set VAL to hold the value.
352 numeric_constant_value(Numeric_constant* val) const
353 { return this->do_numeric_constant_value(val); }
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.
358 string_constant_value(std::string* val) const
359 { return this->do_string_constant_value(val); }
361 // This is called if the value of this expression is being
362 // discarded. This issues warnings about computed values being
363 // unused. This returns true if all is well, false if it issued an
367 { return 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 // If this is a set-and-use-temporary, return the
400 // Set_and_use_temporary_expression. Otherwise, return NULL.
401 Set_and_use_temporary_expression*
402 set_and_use_temporary_expression()
404 return this->convert<Set_and_use_temporary_expression,
405 EXPRESSION_SET_AND_USE_TEMPORARY>();
408 // Return whether this is a sink expression.
410 is_sink_expression() const
411 { return this->classification_ == EXPRESSION_SINK; }
413 // If this is a string expression, return the String_expression
414 // structure. Otherwise, return NULL.
417 { return this->convert<String_expression, EXPRESSION_STRING>(); }
419 // Return whether this is the expression nil.
421 is_nil_expression() const
422 { return this->classification_ == EXPRESSION_NIL; }
424 // If this is an indirection through a pointer, return the
425 // expression being pointed through. Otherwise return this.
429 // If this is a binary expression, return the Binary_expression
430 // structure. Otherwise return NULL.
433 { return this->convert<Binary_expression, EXPRESSION_BINARY>(); }
435 // If this is a call expression, return the Call_expression
436 // structure. Otherwise, return NULL. This is a controlled dynamic
440 { return this->convert<Call_expression, EXPRESSION_CALL>(); }
442 // If this is an expression which refers to a function, return the
443 // Func_expression structure. Otherwise, return NULL.
446 { return this->convert<Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
448 const Func_expression*
449 func_expression() const
450 { return this->convert<const Func_expression, EXPRESSION_FUNC_REFERENCE>(); }
452 // If this is an expression which refers to an unknown name, return
453 // the Unknown_expression structure. Otherwise, return NULL.
456 { return this->convert<Unknown_expression, EXPRESSION_UNKNOWN_REFERENCE>(); }
458 const Unknown_expression*
459 unknown_expression() const
461 return this->convert<const Unknown_expression,
462 EXPRESSION_UNKNOWN_REFERENCE>();
465 // If this is an index expression, return the Index_expression
466 // structure. Otherwise, return NULL.
469 { return this->convert<Index_expression, EXPRESSION_INDEX>(); }
471 // If this is an expression which refers to indexing in a map,
472 // return the Map_index_expression structure. Otherwise, return
474 Map_index_expression*
475 map_index_expression()
476 { return this->convert<Map_index_expression, EXPRESSION_MAP_INDEX>(); }
478 // If this is a bound method expression, return the
479 // Bound_method_expression structure. Otherwise, return NULL.
480 Bound_method_expression*
481 bound_method_expression()
482 { return this->convert<Bound_method_expression, EXPRESSION_BOUND_METHOD>(); }
484 // If this is a reference to a field in a struct, return the
485 // Field_reference_expression structure. Otherwise, return NULL.
486 Field_reference_expression*
487 field_reference_expression()
489 return this->convert<Field_reference_expression,
490 EXPRESSION_FIELD_REFERENCE>();
493 // If this is a reference to a field in an interface, return the
494 // Interface_field_reference_expression structure. Otherwise,
496 Interface_field_reference_expression*
497 interface_field_reference_expression()
499 return this->convert<Interface_field_reference_expression,
500 EXPRESSION_INTERFACE_FIELD_REFERENCE>();
503 // If this is a type guard expression, return the
504 // Type_guard_expression structure. Otherwise, return NULL.
505 Type_guard_expression*
506 type_guard_expression()
507 { return this->convert<Type_guard_expression, EXPRESSION_TYPE_GUARD>(); }
509 // If this is a receive expression, return the Receive_expression
510 // structure. Otherwise, return NULL.
513 { return this->convert<Receive_expression, EXPRESSION_RECEIVE>(); }
515 // Return true if this is a composite literal.
517 is_composite_literal() const;
519 // Return true if this is a composite literal which is not constant.
521 is_nonconstant_composite_literal() const;
523 // Return true if this is a reference to a local variable.
525 is_local_variable() const;
527 // Traverse an expression.
529 traverse(Expression**, Traverse*);
531 // Traverse subexpressions of this expression.
533 traverse_subexpressions(Traverse*);
535 // Lower an expression. This is called immediately after parsing.
536 // FUNCTION is the function we are in; it will be NULL for an
537 // expression initializing a global variable. INSERTER may be used
538 // to insert statements before the statement or initializer
539 // containing this expression; it is normally used to create
540 // temporary variables. IOTA_VALUE is the value that we should give
541 // to any iota expressions. This function must resolve expressions
542 // which could not be fully parsed into their final form. It
543 // returns the same Expression or a new one.
545 lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter,
547 { return this->do_lower(gogo, function, inserter, iota_value); }
549 // Determine the real type of an expression with abstract integer,
550 // floating point, or complex type. TYPE_CONTEXT describes the
553 determine_type(const Type_context*);
555 // Check types in an expression.
557 check_types(Gogo* gogo)
558 { this->do_check_types(gogo); }
560 // Determine the type when there is no context.
562 determine_type_no_context();
564 // Return the current type of the expression. This may be changed
565 // by determine_type.
568 { return this->do_type(); }
570 // Return a copy of an expression.
573 { return this->do_copy(); }
575 // Return whether the expression is addressable--something which may
576 // be used as the operand of the unary & operator.
578 is_addressable() const
579 { return this->do_is_addressable(); }
581 // Note that we are taking the address of this expression. ESCAPES
582 // is true if this address escapes the current function.
584 address_taken(bool escapes)
585 { this->do_address_taken(escapes); }
587 // Return whether this expression must be evaluated in order
588 // according to the order of evaluation rules. This is basically
589 // true of all expressions with side-effects.
591 must_eval_in_order() const
592 { return this->do_must_eval_in_order(); }
594 // Return whether subexpressions of this expression must be
595 // evaluated in order. This is true of index expressions and
596 // pointer indirections. This sets *SKIP to the number of
597 // subexpressions to skip during traversing, as index expressions
598 // only requiring moving the index, not the array.
600 must_eval_subexpressions_in_order(int* skip) const
603 return this->do_must_eval_subexpressions_in_order(skip);
606 // Return the tree for this expression.
608 get_tree(Translate_context*);
610 // Return a tree handling any conversions which must be done during
613 convert_for_assignment(Translate_context*, Type* lhs_type, Type* rhs_type,
614 tree rhs_tree, Location location);
616 // Return a tree converting a value of one interface type to another
617 // interface type. If FOR_TYPE_GUARD is true this is for a type
620 convert_interface_to_interface(Translate_context*, Type* lhs_type,
621 Type* rhs_type, tree rhs_tree,
622 bool for_type_guard, Location);
624 // Return a tree implementing the comparison LHS_TREE OP RHS_TREE.
625 // TYPE is the type of both sides.
627 comparison_tree(Translate_context*, Type* result_type, Operator op,
628 Type* left_type, tree left_tree, Type* right_type,
629 tree right_tree, Location);
631 // Return a tree for the multi-precision integer VAL in TYPE.
633 integer_constant_tree(mpz_t val, tree type);
635 // Return a tree for the floating point value VAL in TYPE.
637 float_constant_tree(mpfr_t val, tree type);
639 // Return a tree for the complex value REAL/IMAG in TYPE.
641 complex_constant_tree(mpfr_t real, mpfr_t imag, tree type);
643 // Export the expression. This is only used for constants. It will
644 // be used for things like values of named constants and sizes of
647 export_expression(Export* exp) const
648 { this->do_export(exp); }
650 // Import an expression.
652 import_expression(Import*);
654 // Return a tree which checks that VAL, of arbitrary integer type,
655 // is non-negative and is not more than the maximum value of
656 // BOUND_TYPE. If SOFAR is not NULL, it is or'red into the result.
657 // The return value may be NULL if SOFAR is NULL.
659 check_bounds(tree val, tree bound_type, tree sofar, Location);
661 // Dump an expression to a dump constext.
663 dump_expression(Ast_dump_context*) const;
666 // May be implemented by child class: traverse the expressions.
668 do_traverse(Traverse*);
670 // Return a lowered expression.
672 do_lower(Gogo*, Named_object*, Statement_inserter*, int)
675 // Return whether this is a constant expression.
677 do_is_constant() const
680 // Return whether this is a constant expression of numeric type, and
681 // set the Numeric_constant to the value.
683 do_numeric_constant_value(Numeric_constant*) const
686 // Return whether this is a constant expression of string type, and
687 // set VAL to the value.
689 do_string_constant_value(std::string*) const
692 // Called by the parser if the value is being discarded.
694 do_discarding_value();
696 // Child class holds type.
700 // Child class implements determining type information.
702 do_determine_type(const Type_context*) = 0;
704 // Child class implements type checking if needed.
706 do_check_types(Gogo*)
709 // Child class implements copying.
713 // Child class implements whether the expression is addressable.
715 do_is_addressable() const
718 // Child class implements taking the address of an expression.
720 do_address_taken(bool)
723 // Child class implements whether this expression must be evaluated
726 do_must_eval_in_order() const
729 // Child class implements whether this expressions requires that
730 // subexpressions be evaluated in order. The child implementation
731 // may set *SKIP if it should be non-zero.
733 do_must_eval_subexpressions_in_order(int* /* skip */) const
736 // Child class implements conversion to tree.
738 do_get_tree(Translate_context*) = 0;
740 // Child class implements export.
742 do_export(Export*) const;
744 // For children to call to give an error for an unused value.
746 unused_value_error();
748 // For children to call when they detect that they are in error.
752 // For children to call to report an error conveniently.
754 report_error(const char*);
756 // Child class implements dumping to a dump context.
758 do_dump_expression(Ast_dump_context*) const = 0;
761 // Convert to the desired statement classification, or return NULL.
762 // This is a controlled dynamic cast.
763 template<typename Expression_class,
764 Expression_classification expr_classification>
768 return (this->classification_ == expr_classification
769 ? static_cast<Expression_class*>(this)
773 template<typename Expression_class,
774 Expression_classification expr_classification>
775 const Expression_class*
778 return (this->classification_ == expr_classification
779 ? static_cast<const Expression_class*>(this)
784 convert_type_to_interface(Translate_context*, Type*, Type*, tree,
788 get_interface_type_descriptor(Translate_context*, Type*, tree,
792 convert_interface_to_type(Translate_context*, Type*, Type*, tree,
795 // The expression classification.
796 Expression_classification classification_;
797 // The location in the input file.
801 // A list of Expressions.
803 class Expression_list
810 // Return whether the list is empty.
813 { return this->entries_.empty(); }
815 // Return the number of entries in the list.
818 { return this->entries_.size(); }
820 // Add an entry to the end of the list.
822 push_back(Expression* expr)
823 { this->entries_.push_back(expr); }
826 append(Expression_list* add)
827 { this->entries_.insert(this->entries_.end(), add->begin(), add->end()); }
829 // Reserve space in the list.
832 { this->entries_.reserve(size); }
834 // Traverse the expressions in the list.
842 // Return true if the list contains an error expression.
844 contains_error() const;
846 // Retrieve an element by index.
849 { return this->entries_.at(i); }
851 // Return the first and last elements.
854 { return this->entries_.front(); }
858 { return this->entries_.front(); }
862 { return this->entries_.back(); }
866 { return this->entries_.back(); }
870 typedef std::vector<Expression*>::iterator iterator;
871 typedef std::vector<Expression*>::const_iterator const_iterator;
875 { return this->entries_.begin(); }
879 { return this->entries_.begin(); }
883 { return this->entries_.end(); }
887 { return this->entries_.end(); }
892 { this->entries_.erase(p); }
895 std::vector<Expression*> entries_;
898 // An abstract base class for an expression which is only used by the
899 // parser, and is lowered in the lowering pass.
901 class Parser_expression : public Expression
904 Parser_expression(Expression_classification classification,
906 : Expression(classification, location)
911 do_lower(Gogo*, Named_object*, Statement_inserter*, int) = 0;
917 do_determine_type(const Type_context*)
918 { go_unreachable(); }
921 do_check_types(Gogo*)
922 { go_unreachable(); }
925 do_get_tree(Translate_context*)
926 { go_unreachable(); }
929 // An expression which is simply a variable.
931 class Var_expression : public Expression
934 Var_expression(Named_object* variable, Location location)
935 : Expression(EXPRESSION_VAR_REFERENCE, location),
939 // Return the variable.
942 { return this->variable_; }
946 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
952 do_determine_type(const Type_context*);
959 do_is_addressable() const
963 do_address_taken(bool);
966 do_get_tree(Translate_context*);
969 do_dump_expression(Ast_dump_context*) const;
972 // The variable we are referencing.
973 Named_object* variable_;
976 // A reference to a temporary variable.
978 class Temporary_reference_expression : public Expression
981 Temporary_reference_expression(Temporary_statement* statement,
983 : Expression(EXPRESSION_TEMPORARY_REFERENCE, location),
984 statement_(statement), is_lvalue_(false)
987 // Indicate that this reference appears on the left hand side of an
988 // assignment statement.
991 { this->is_lvalue_ = true; }
998 do_determine_type(const Type_context*)
1003 { return make_temporary_reference(this->statement_, this->location()); }
1006 do_is_addressable() const
1010 do_address_taken(bool);
1013 do_get_tree(Translate_context*);
1016 do_dump_expression(Ast_dump_context*) const;
1019 // The statement where the temporary variable is defined.
1020 Temporary_statement* statement_;
1021 // Whether this reference appears on the left hand side of an
1022 // assignment statement.
1026 // Set and use a temporary variable.
1028 class Set_and_use_temporary_expression : public Expression
1031 Set_and_use_temporary_expression(Temporary_statement* statement,
1032 Expression* expr, Location location)
1033 : Expression(EXPRESSION_SET_AND_USE_TEMPORARY, location),
1034 statement_(statement), expr_(expr)
1037 // Return the temporary.
1038 Temporary_statement*
1040 { return this->statement_; }
1042 // Return the expression.
1045 { return this->expr_; }
1049 do_traverse(Traverse* traverse)
1050 { return Expression::traverse(&this->expr_, traverse); }
1056 do_determine_type(const Type_context*)
1062 return make_set_and_use_temporary(this->statement_, this->expr_,
1067 do_is_addressable() const
1071 do_address_taken(bool);
1074 do_get_tree(Translate_context*);
1077 do_dump_expression(Ast_dump_context*) const;
1080 // The statement where the temporary variable is defined.
1081 Temporary_statement* statement_;
1082 // The expression to assign to the temporary.
1086 // A string expression.
1088 class String_expression : public Expression
1091 String_expression(const std::string& val, Location location)
1092 : Expression(EXPRESSION_STRING, location),
1093 val_(val), type_(NULL)
1098 { return this->val_; }
1105 do_is_constant() const
1109 do_string_constant_value(std::string* val) const
1119 do_determine_type(const Type_context*);
1126 do_get_tree(Translate_context*);
1128 // Write string literal to a string dump.
1130 export_string(String_dump* exp, const String_expression* str);
1133 do_export(Export*) const;
1136 do_dump_expression(Ast_dump_context*) const;
1139 // The string value. This is immutable.
1140 const std::string val_;
1141 // The type as determined by context.
1145 // A binary expression.
1147 class Binary_expression : public Expression
1150 Binary_expression(Operator op, Expression* left, Expression* right,
1152 : Expression(EXPRESSION_BINARY, location),
1153 op_(op), left_(left), right_(right), type_(NULL)
1156 // Return the operator.
1159 { return this->op_; }
1161 // Return the left hand expression.
1164 { return this->left_; }
1166 // Return the right hand expression.
1169 { return this->right_; }
1171 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
1172 // Return true if this could be done, false if not. Issue errors at
1173 // LOCATION as appropriate.
1175 eval_constant(Operator op, Numeric_constant* left_nc,
1176 Numeric_constant* right_nc, Location location,
1177 Numeric_constant* nc);
1179 // Compare constants LEFT_NC and RIGHT_NC according to OP, setting
1180 // *RESULT. Return true if this could be done, false if not. Issue
1181 // errors at LOCATION as appropriate.
1183 compare_constant(Operator op, Numeric_constant* left_nc,
1184 Numeric_constant* right_nc, Location location,
1190 // Report an error if OP can not be applied to TYPE. Return whether
1191 // it can. OTYPE is the type of the other operand.
1193 check_operator_type(Operator op, Type* type, Type* otype, Location);
1197 do_traverse(Traverse* traverse);
1200 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1203 do_is_constant() const
1204 { return this->left_->is_constant() && this->right_->is_constant(); }
1207 do_numeric_constant_value(Numeric_constant*) const;
1210 do_discarding_value();
1216 do_determine_type(const Type_context*);
1219 do_check_types(Gogo*);
1224 return Expression::make_binary(this->op_, this->left_->copy(),
1225 this->right_->copy(), this->location());
1229 do_get_tree(Translate_context*);
1232 do_export(Export*) const;
1235 do_dump_expression(Ast_dump_context*) const;
1239 operation_type(Operator op, Type* left_type, Type* right_type,
1240 Type** result_type);
1243 cmp_to_bool(Operator op, int cmp);
1246 eval_integer(Operator op, const Numeric_constant*, const Numeric_constant*,
1247 Location, Numeric_constant*);
1250 eval_float(Operator op, const Numeric_constant*, const Numeric_constant*,
1251 Location, Numeric_constant*);
1254 eval_complex(Operator op, const Numeric_constant*, const Numeric_constant*,
1255 Location, Numeric_constant*);
1258 compare_integer(const Numeric_constant*, const Numeric_constant*, int*);
1261 compare_float(const Numeric_constant*, const Numeric_constant *, int*);
1264 compare_complex(const Numeric_constant*, const Numeric_constant*, int*);
1267 lower_struct_comparison(Gogo*, Statement_inserter*);
1270 lower_array_comparison(Gogo*, Statement_inserter*);
1273 lower_compare_to_memcmp(Gogo*, Statement_inserter*);
1276 operand_address(Statement_inserter*, Expression*);
1278 // The binary operator to apply.
1280 // The left hand side operand.
1282 // The right hand side operand.
1284 // The type of a comparison operation.
1288 // A call expression. The go statement needs to dig inside this.
1290 class Call_expression : public Expression
1293 Call_expression(Expression* fn, Expression_list* args, bool is_varargs,
1295 : Expression(EXPRESSION_CALL, location),
1296 fn_(fn), args_(args), type_(NULL), results_(NULL), tree_(NULL),
1297 is_varargs_(is_varargs), are_hidden_fields_ok_(false),
1298 varargs_are_lowered_(false), types_are_determined_(false),
1299 is_deferred_(false), issued_error_(false)
1302 // The function to call.
1305 { return this->fn_; }
1310 { return this->args_; }
1312 const Expression_list*
1314 { return this->args_; }
1316 // Get the function type.
1318 get_function_type() const;
1320 // Return the number of values this call will return.
1322 result_count() const;
1324 // Return the temporary variable which holds result I. This is only
1325 // valid after the expression has been lowered, and is only valid
1326 // for calls which return multiple results.
1327 Temporary_statement*
1328 result(size_t i) const;
1330 // Return whether this is a call to the predeclared function
1333 is_recover_call() const;
1335 // Set the argument for a call to recover.
1337 set_recover_arg(Expression*);
1339 // Whether the last argument is a varargs argument (f(a...)).
1342 { return this->is_varargs_; }
1344 // Note that varargs have already been lowered.
1346 set_varargs_are_lowered()
1347 { this->varargs_are_lowered_ = true; }
1349 // Note that it is OK for this call to set hidden fields when
1350 // passing arguments.
1352 set_hidden_fields_are_ok()
1353 { this->are_hidden_fields_ok_ = true; }
1355 // Whether this call is being deferred.
1358 { return this->is_deferred_; }
1360 // Note that the call is being deferred.
1363 { this->is_deferred_ = true; }
1365 // We have found an error with this call expression; return true if
1366 // we should report it.
1372 do_traverse(Traverse*);
1375 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1378 do_discarding_value()
1385 do_determine_type(const Type_context*);
1388 do_check_types(Gogo*);
1393 return Expression::make_call(this->fn_->copy(),
1394 (this->args_ == NULL
1396 : this->args_->copy()),
1397 this->is_varargs_, this->location());
1401 do_must_eval_in_order() const;
1404 do_get_tree(Translate_context*);
1407 do_is_recover_call() const;
1410 do_set_recover_arg(Expression*);
1412 // Let a builtin expression change the argument list.
1414 set_args(Expression_list* args)
1415 { this->args_ = args; }
1417 // Let a builtin expression lower varargs.
1419 lower_varargs(Gogo*, Named_object* function, Statement_inserter* inserter,
1420 Type* varargs_type, size_t param_count);
1422 // Let a builtin expression check whether types have been
1425 determining_types();
1428 do_dump_expression(Ast_dump_context*) const;
1432 check_argument_type(int, const Type*, const Type*, Location, bool);
1435 interface_method_function(Translate_context*,
1436 Interface_field_reference_expression*,
1440 set_results(Translate_context*, tree);
1442 // The function to call.
1444 // The arguments to pass. This may be NULL if there are no
1446 Expression_list* args_;
1447 // The type of the expression, to avoid recomputing it.
1449 // The list of temporaries which will hold the results if the
1450 // function returns a tuple.
1451 std::vector<Temporary_statement*>* results_;
1452 // The tree for the call, used for a call which returns a tuple.
1454 // True if the last argument is a varargs argument (f(a...)).
1456 // True if this statement may pass hidden fields in the arguments.
1457 // This is used for generated method stubs.
1458 bool are_hidden_fields_ok_;
1459 // True if varargs have already been lowered.
1460 bool varargs_are_lowered_;
1461 // True if types have been determined.
1462 bool types_are_determined_;
1463 // True if the call is an argument to a defer statement.
1465 // True if we reported an error about a mismatch between call
1466 // results and uses. This is to avoid producing multiple errors
1467 // when there are multiple Call_result_expressions.
1471 // An expression which represents a pointer to a function.
1473 class Func_expression : public Expression
1476 Func_expression(Named_object* function, Expression* closure,
1478 : Expression(EXPRESSION_FUNC_REFERENCE, location),
1479 function_(function), closure_(closure)
1482 // Return the object associated with the function.
1484 named_object() const
1485 { return this->function_; }
1487 // Return the closure for this function. This will return NULL if
1488 // the function has no closure, which is the normal case.
1491 { return this->closure_; }
1493 // Return a tree for this function without evaluating the closure.
1495 get_tree_without_closure(Gogo*);
1499 do_traverse(Traverse*);
1505 do_determine_type(const Type_context*)
1507 if (this->closure_ != NULL)
1508 this->closure_->determine_type_no_context();
1514 return Expression::make_func_reference(this->function_,
1515 (this->closure_ == NULL
1517 : this->closure_->copy()),
1522 do_get_tree(Translate_context*);
1525 do_dump_expression(Ast_dump_context*) const;
1528 // The function itself.
1529 Named_object* function_;
1530 // A closure. This is normally NULL. For a nested function, it may
1531 // be a heap-allocated struct holding pointers to all the variables
1532 // referenced by this function and defined in enclosing functions.
1533 Expression* closure_;
1536 // A reference to an unknown name.
1538 class Unknown_expression : public Parser_expression
1541 Unknown_expression(Named_object* named_object, Location location)
1542 : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE, location),
1543 named_object_(named_object), no_error_message_(false),
1544 is_composite_literal_key_(false)
1547 // The associated named object.
1549 named_object() const
1550 { return this->named_object_; }
1552 // The name of the identifier which was unknown.
1556 // Call this to indicate that we should not give an error if this
1557 // name is never defined. This is used to avoid knock-on errors
1558 // during an erroneous parse.
1560 set_no_error_message()
1561 { this->no_error_message_ = true; }
1563 // Note that this expression is being used as the key in a composite
1564 // literal, so it may be OK if it is not resolved.
1566 set_is_composite_literal_key()
1567 { this->is_composite_literal_key_ = true; }
1569 // Note that this expression should no longer be treated as a
1570 // composite literal key.
1572 clear_is_composite_literal_key()
1573 { this->is_composite_literal_key_ = false; }
1577 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1581 { return new Unknown_expression(this->named_object_, this->location()); }
1584 do_dump_expression(Ast_dump_context*) const;
1587 // The unknown name.
1588 Named_object* named_object_;
1589 // True if we should not give errors if this is undefined. This is
1590 // used if there was a parse failure.
1591 bool no_error_message_;
1592 // True if this is the key in a composite literal.
1593 bool is_composite_literal_key_;
1596 // An index expression. This is lowered to an array index, a string
1597 // index, or a map index.
1599 class Index_expression : public Parser_expression
1602 Index_expression(Expression* left, Expression* start, Expression* end,
1604 : Parser_expression(EXPRESSION_INDEX, location),
1605 left_(left), start_(start), end_(end), is_lvalue_(false)
1608 // Record that this expression is an lvalue.
1611 { this->is_lvalue_ = true; }
1613 // Dump an index expression, i.e. an expression of the form
1614 // expr[expr] or expr[expr:expr], to a dump context.
1616 dump_index_expression(Ast_dump_context*, const Expression* expr,
1617 const Expression* start, const Expression* end);
1621 do_traverse(Traverse*);
1624 do_lower(Gogo*, Named_object*, Statement_inserter*, int);
1629 return new Index_expression(this->left_->copy(), this->start_->copy(),
1632 : this->end_->copy()),
1637 do_must_eval_subexpressions_in_order(int* skip) const
1644 do_dump_expression(Ast_dump_context*) const;
1647 // The expression being indexed.
1651 // The second index. This is NULL for an index, non-NULL for a
1654 // Whether this is being used as an l-value. We set this during the
1655 // parse because map index expressions need to know.
1659 // An index into a map.
1661 class Map_index_expression : public Expression
1664 Map_index_expression(Expression* map, Expression* index,
1666 : Expression(EXPRESSION_MAP_INDEX, location),
1667 map_(map), index_(index), is_lvalue_(false),
1668 is_in_tuple_assignment_(false)
1674 { return this->map_; }
1678 { return this->map_; }
1680 // Return the index.
1683 { return this->index_; }
1687 { return this->index_; }
1689 // Get the type of the map being indexed.
1691 get_map_type() const;
1693 // Record that this map expression is an lvalue. The difference is
1694 // that an lvalue always inserts the key.
1697 { this->is_lvalue_ = true; }
1699 // Return whether this map expression occurs in an assignment to a
1702 is_in_tuple_assignment() const
1703 { return this->is_in_tuple_assignment_; }
1705 // Record that this map expression occurs in an assignment to a pair
1708 set_is_in_tuple_assignment()
1709 { this->is_in_tuple_assignment_ = true; }
1711 // Return a tree for the map index. This returns a tree which
1712 // evaluates to a pointer to a value in the map. If INSERT is true,
1713 // the key will be inserted if not present, and the value pointer
1714 // will be zero initialized. If INSERT is false, and the key is not
1715 // present in the map, the pointer will be NULL.
1717 get_value_pointer(Translate_context*, bool insert);
1721 do_traverse(Traverse*);
1727 do_determine_type(const Type_context*);
1730 do_check_types(Gogo*);
1735 return Expression::make_map_index(this->map_->copy(),
1736 this->index_->copy(),
1741 do_must_eval_subexpressions_in_order(int* skip) const
1747 // A map index expression is an lvalue but it is not addressable.
1750 do_get_tree(Translate_context*);
1753 do_dump_expression(Ast_dump_context*) const;
1756 // The map we are looking into.
1760 // Whether this is an lvalue.
1762 // Whether this is in a tuple assignment to a pair of values.
1763 bool is_in_tuple_assignment_;
1766 // An expression which represents a method bound to its first
1769 class Bound_method_expression : public Expression
1772 Bound_method_expression(Expression* expr, Named_object* method,
1774 : Expression(EXPRESSION_BOUND_METHOD, location),
1775 expr_(expr), expr_type_(NULL), method_(method)
1778 // Return the object which is the first argument.
1781 { return this->expr_; }
1783 // Return the implicit type of the first argument. This will be
1784 // non-NULL when using a method from an anonymous field without
1785 // using an explicit stub.
1787 first_argument_type() const
1788 { return this->expr_type_; }
1790 // Return the method function.
1793 { return this->method_; }
1795 // Set the implicit type of the expression.
1797 set_first_argument_type(Type* type)
1798 { this->expr_type_ = type; }
1802 do_traverse(Traverse*);
1808 do_determine_type(const Type_context*);
1811 do_check_types(Gogo*);
1816 return new Bound_method_expression(this->expr_->copy(), this->method_,
1821 do_get_tree(Translate_context*);
1824 do_dump_expression(Ast_dump_context*) const;
1827 // The object used to find the method. This is passed to the method
1828 // as the first argument.
1830 // The implicit type of the object to pass to the method. This is
1831 // NULL in the normal case, non-NULL when using a method from an
1832 // anonymous field which does not require a stub.
1834 // The method itself.
1835 Named_object* method_;
1838 // A reference to a field in a struct.
1840 class Field_reference_expression : public Expression
1843 Field_reference_expression(Expression* expr, unsigned int field_index,
1845 : Expression(EXPRESSION_FIELD_REFERENCE, location),
1846 expr_(expr), field_index_(field_index)
1849 // Return the struct expression.
1852 { return this->expr_; }
1854 // Return the field index.
1857 { return this->field_index_; }
1859 // Set the struct expression. This is used when parsing.
1861 set_struct_expression(Expression* expr)
1863 go_assert(this->expr_ == NULL);
1869 do_traverse(Traverse* traverse)
1870 { return Expression::traverse(&this->expr_, traverse); }
1876 do_determine_type(const Type_context*)
1877 { this->expr_->determine_type_no_context(); }
1880 do_check_types(Gogo*);
1885 return Expression::make_field_reference(this->expr_->copy(),
1891 do_is_addressable() const
1892 { return this->expr_->is_addressable(); }
1895 do_address_taken(bool escapes)
1896 { this->expr_->address_taken(escapes); }
1899 do_get_tree(Translate_context*);
1902 do_dump_expression(Ast_dump_context*) const;
1905 // The expression we are looking into. This should have a type of
1908 // The zero-based index of the field we are retrieving.
1909 unsigned int field_index_;
1912 // A reference to a field of an interface.
1914 class Interface_field_reference_expression : public Expression
1917 Interface_field_reference_expression(Expression* expr,
1918 const std::string& name,
1920 : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE, location),
1921 expr_(expr), name_(name)
1924 // Return the expression for the interface object.
1927 { return this->expr_; }
1929 // Return the name of the method to call.
1932 { return this->name_; }
1934 // Return a tree for the pointer to the function to call, given a
1935 // tree for the expression.
1937 get_function_tree(Translate_context*, tree);
1939 // Return a tree for the first argument to pass to the interface
1940 // function, given a tree for the expression. This is the real
1941 // object associated with the interface object.
1943 get_underlying_object_tree(Translate_context*, tree);
1947 do_traverse(Traverse* traverse);
1953 do_determine_type(const Type_context*);
1956 do_check_types(Gogo*);
1961 return Expression::make_interface_field_reference(this->expr_->copy(),
1967 do_get_tree(Translate_context*);
1970 do_dump_expression(Ast_dump_context*) const;
1973 // The expression for the interface object. This should have a type
1974 // of interface or pointer to interface.
1976 // The field we are retrieving--the name of the method.
1980 // A type guard expression.
1982 class Type_guard_expression : public Expression
1985 Type_guard_expression(Expression* expr, Type* type, Location location)
1986 : Expression(EXPRESSION_TYPE_GUARD, location),
1987 expr_(expr), type_(type)
1990 // Return the expression to convert.
1993 { return this->expr_; }
1995 // Return the type to which to convert.
1998 { return this->type_; }
2002 do_traverse(Traverse* traverse);
2006 { return this->type_; }
2009 do_determine_type(const Type_context*)
2010 { this->expr_->determine_type_no_context(); }
2013 do_check_types(Gogo*);
2018 return new Type_guard_expression(this->expr_->copy(), this->type_,
2023 do_get_tree(Translate_context*);
2026 do_dump_expression(Ast_dump_context*) const;
2029 // The expression to convert.
2031 // The type to which to convert.
2035 // A receive expression.
2037 class Receive_expression : public Expression
2040 Receive_expression(Expression* channel, Location location)
2041 : Expression(EXPRESSION_RECEIVE, location),
2045 // Return the channel.
2048 { return this->channel_; }
2052 do_traverse(Traverse* traverse)
2053 { return Expression::traverse(&this->channel_, traverse); }
2056 do_discarding_value()
2063 do_determine_type(const Type_context*)
2064 { this->channel_->determine_type_no_context(); }
2067 do_check_types(Gogo*);
2072 return Expression::make_receive(this->channel_->copy(), this->location());
2076 do_must_eval_in_order() const
2080 do_get_tree(Translate_context*);
2083 do_dump_expression(Ast_dump_context*) const;
2086 // The channel from which we are receiving.
2087 Expression* channel_;
2090 // A numeric constant. This is used both for untyped constants and
2091 // for constants that have a type.
2093 class Numeric_constant
2097 : classification_(NC_INVALID), type_(NULL)
2100 ~Numeric_constant();
2102 Numeric_constant(const Numeric_constant&);
2104 Numeric_constant& operator=(const Numeric_constant&);
2106 // Set to an unsigned long value.
2108 set_unsigned_long(Type*, unsigned long);
2110 // Set to an integer value.
2112 set_int(Type*, const mpz_t);
2114 // Set to a rune value.
2116 set_rune(Type*, const mpz_t);
2118 // Set to a floating point value.
2120 set_float(Type*, const mpfr_t);
2122 // Set to a complex value.
2124 set_complex(Type*, const mpfr_t, const mpfr_t);
2129 { return this->classification_ == Numeric_constant::NC_INT; }
2133 { return this->classification_ == Numeric_constant::NC_RUNE; }
2137 { return this->classification_ == Numeric_constant::NC_FLOAT; }
2141 { return this->classification_ == Numeric_constant::NC_COMPLEX; }
2143 // Value retrievers. These will initialize the values as well as
2144 // set them. GET_INT is only valid if IS_INT returns true, and
2145 // likewise respectively.
2147 get_int(mpz_t*) const;
2150 get_rune(mpz_t*) const;
2153 get_float(mpfr_t*) const;
2156 get_complex(mpfr_t*, mpfr_t*) const;
2158 // Codes returned by to_unsigned_long.
2159 enum To_unsigned_long
2161 // Value is integer and fits in unsigned long.
2163 // Value is not integer.
2165 // Value is integer but is negative.
2167 // Value is non-negative integer but does not fit in unsigned
2172 // If the value can be expressed as an integer that fits in an
2173 // unsigned long, set *VAL and return NC_UL_VALID. Otherwise return
2174 // one of the other To_unsigned_long codes.
2176 to_unsigned_long(unsigned long* val) const;
2178 // If the value can be expressed as an int, return true and
2179 // initialize and set VAL. This will return false for a value with
2180 // an explicit float or complex type, even if the value is integral.
2182 to_int(mpz_t* val) const;
2184 // If the value can be expressed as a float, return true and
2185 // initialize and set VAL.
2187 to_float(mpfr_t* val) const;
2189 // If the value can be expressed as a complex, return true and
2190 // initialize and set VR and VI.
2192 to_complex(mpfr_t* vr, mpfr_t* vi) const;
2198 // If the constant can be expressed in TYPE, then set the type of
2199 // the constant to TYPE and return true. Otherwise return false,
2200 // and, if ISSUE_ERROR is true, issue an error message. LOCATION is
2201 // the location to use for the error.
2203 set_type(Type* type, bool issue_error, Location location);
2205 // Return an Expression for this value.
2207 expression(Location) const;
2214 mpz_to_unsigned_long(const mpz_t ival, unsigned long *val) const;
2217 mpfr_to_unsigned_long(const mpfr_t fval, unsigned long *val) const;
2220 check_int_type(Integer_type*, bool, Location) const;
2223 check_float_type(Float_type*, bool, Location);
2226 check_complex_type(Complex_type*, bool, Location);
2228 // The kinds of constants.
2238 // The kind of constant.
2239 Classification classification_;
2243 // If NC_INT or NC_RUNE.
2254 // The type if there is one. This will be NULL for an untyped
2259 #endif // !defined(GO_EXPRESSIONS_H)