1 // types.h -- Go frontend types. -*- 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.
13 class Typed_identifier
;
14 class Typed_identifier_list
;
21 class Struct_field_list
;
29 class Forward_declaration_type
;
32 class Type_hash_identical
;
35 class Expression_list
;
36 class Call_expression
;
37 class Field_reference_expression
;
38 class Bound_method_expression
;
42 class Translate_context
;
46 // Type codes used in type descriptors. These must match the values
47 // in libgo/runtime/go-type.h. They also match the values in the gc
48 // compiler in src/cmd/gc/reflect.c and src/pkg/runtime/type.go,
49 // although this is not required.
51 static const int RUNTIME_TYPE_KIND_BOOL
= 1;
52 static const int RUNTIME_TYPE_KIND_INT
= 2;
53 static const int RUNTIME_TYPE_KIND_INT8
= 3;
54 static const int RUNTIME_TYPE_KIND_INT16
= 4;
55 static const int RUNTIME_TYPE_KIND_INT32
= 5;
56 static const int RUNTIME_TYPE_KIND_INT64
= 6;
57 static const int RUNTIME_TYPE_KIND_UINT
= 7;
58 static const int RUNTIME_TYPE_KIND_UINT8
= 8;
59 static const int RUNTIME_TYPE_KIND_UINT16
= 9;
60 static const int RUNTIME_TYPE_KIND_UINT32
= 10;
61 static const int RUNTIME_TYPE_KIND_UINT64
= 11;
62 static const int RUNTIME_TYPE_KIND_UINTPTR
= 12;
63 static const int RUNTIME_TYPE_KIND_FLOAT
= 13;
64 static const int RUNTIME_TYPE_KIND_FLOAT32
= 14;
65 static const int RUNTIME_TYPE_KIND_FLOAT64
= 15;
66 static const int RUNTIME_TYPE_KIND_COMPLEX
= 16;
67 static const int RUNTIME_TYPE_KIND_COMPLEX64
= 17;
68 static const int RUNTIME_TYPE_KIND_COMPLEX128
= 18;
69 static const int RUNTIME_TYPE_KIND_ARRAY
= 19;
70 static const int RUNTIME_TYPE_KIND_CHAN
= 20;
71 static const int RUNTIME_TYPE_KIND_FUNC
= 21;
72 static const int RUNTIME_TYPE_KIND_INTERFACE
= 22;
73 static const int RUNTIME_TYPE_KIND_MAP
= 23;
74 static const int RUNTIME_TYPE_KIND_PTR
= 24;
75 static const int RUNTIME_TYPE_KIND_SLICE
= 25;
76 static const int RUNTIME_TYPE_KIND_STRING
= 26;
77 static const int RUNTIME_TYPE_KIND_STRUCT
= 27;
78 static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER
= 28;
80 // To build the complete list of methods for a named type we need to
81 // gather all methods from anonymous fields. Those methods may
82 // require an arbitrary set of indirections and field offsets. There
83 // is also the possibility of ambiguous methods, which we could ignore
84 // except that we want to give a better error message for that case.
85 // This is a base class. There are two types of methods: named
86 // methods, and methods which are inherited from an anonymous field of
92 // For methods in anonymous types we need to know the sequence of
93 // field references used to extract the pointer to pass to the
94 // method. Since each method for a particular anonymous field will
95 // have the sequence of field indexes, and since the indexes can be
96 // shared going down the chain, we use a manually managed linked
97 // list. The first entry in the list is the field index for the
98 // last field, the one passed to the method.
102 const Field_indexes
* next
;
103 unsigned int field_index
;
109 // Get the list of field indexes.
111 field_indexes() const
112 { return this->field_indexes_
; }
117 { return this->depth_
; }
119 // Return whether this is a value method--a method which does not
120 // require a pointer expression.
122 is_value_method() const
123 { return this->is_value_method_
; }
125 // Return whether we need a stub method--this is true if we can't
126 // just pass the main object to the method.
128 needs_stub_method() const
129 { return this->needs_stub_method_
; }
131 // Return whether this is an ambiguous method name.
134 { return this->is_ambiguous_
; }
136 // Note that this method is ambiguous.
139 { this->is_ambiguous_
= true; }
141 // Return the type of the method.
144 { return this->do_type(); }
146 // Return the location of the method receiver.
148 receiver_location() const
149 { return this->do_receiver_location(); }
151 // Return an expression which binds this method to EXPR. This is
152 // something which can be used with a function call.
154 bind_method(Expression
* expr
, source_location location
) const;
156 // Return the named object for this method. This may only be called
157 // after methods are finalized.
159 named_object() const;
161 // Get the stub object.
165 gcc_assert(this->stub_
!= NULL
);
169 // Set the stub object.
171 set_stub_object(Named_object
* no
)
173 gcc_assert(this->stub_
== NULL
);
178 // These objects are only built by the child classes.
179 Method(const Field_indexes
* field_indexes
, unsigned int depth
,
180 bool is_value_method
, bool needs_stub_method
)
181 : field_indexes_(field_indexes
), depth_(depth
), stub_(NULL
),
182 is_value_method_(is_value_method
), needs_stub_method_(needs_stub_method
),
186 // The named object for this method.
187 virtual Named_object
*
188 do_named_object() const = 0;
190 // The type of the method.
191 virtual Function_type
*
194 // Return the location of the method receiver.
195 virtual source_location
196 do_receiver_location() const = 0;
198 // Bind a method to an object.
200 do_bind_method(Expression
* expr
, source_location location
) const = 0;
203 // The sequence of field indexes used for this method. If this is
204 // NULL, then the method is defined for the current type.
205 const Field_indexes
* field_indexes_
;
206 // The depth at which this method was found.
208 // If a stub method is required, this is its object. This is only
209 // set after stub methods are built in finalize_methods.
211 // Whether this is a value method--a method that does not require a
213 bool is_value_method_
;
214 // Whether a stub method is required.
215 bool needs_stub_method_
;
216 // Whether this method is ambiguous.
220 // A named method. This is what you get with a method declaration,
221 // either directly on the type, or inherited from some anonymous
224 class Named_method
: public Method
227 Named_method(Named_object
* named_object
, const Field_indexes
* field_indexes
,
228 unsigned int depth
, bool is_value_method
,
229 bool needs_stub_method
)
230 : Method(field_indexes
, depth
, is_value_method
, needs_stub_method
),
231 named_object_(named_object
)
235 // Get the Named_object for the method.
237 do_named_object() const
238 { return this->named_object_
; }
240 // The type of the method.
244 // Return the location of the method receiver.
246 do_receiver_location() const;
248 // Bind a method to an object.
250 do_bind_method(Expression
* expr
, source_location location
) const;
253 // The method itself. For a method which needs a stub, this starts
254 // out as the underlying method, and is later replaced with the stub
256 Named_object
* named_object_
;
259 // An interface method. This is used when an interface appears as an
260 // anonymous field in a named struct.
262 class Interface_method
: public Method
265 Interface_method(const std::string
& name
, source_location location
,
266 Function_type
* fntype
, const Field_indexes
* field_indexes
,
268 : Method(field_indexes
, depth
, true, true),
269 name_(name
), location_(location
), fntype_(fntype
)
273 // Get the Named_object for the method. This should never be
274 // called, as we always create a stub.
276 do_named_object() const
277 { gcc_unreachable(); }
279 // The type of the method.
282 { return this->fntype_
; }
284 // Return the location of the method receiver.
286 do_receiver_location() const
287 { return this->location_
; }
289 // Bind a method to an object.
291 do_bind_method(Expression
* expr
, source_location location
) const;
294 // The name of the interface method to call.
296 // The location of the definition of the interface method.
297 source_location location_
;
298 // The type of the interface method.
299 Function_type
* fntype_
;
302 // A mapping from method name to Method. This is a wrapper around a
308 typedef Unordered_map(std::string
, Method
*) Method_map
;
311 typedef Method_map::const_iterator const_iterator
;
317 // Insert a new method. Returns true if it was inserted, false if
318 // it was overidden or ambiguous.
320 insert(const std::string
& name
, Method
* m
);
322 // The number of (unambiguous) methods.
329 { return this->methods_
.begin(); }
333 { return this->methods_
.end(); }
337 find(const std::string
& name
) const
338 { return this->methods_
.find(name
); }
344 // The base class for all types.
349 // The types of types.
350 enum Type_classification
363 TYPE_CALL_MULTIPLE_RESULT
,
383 // Get the unnamed bool type.
387 // Get the named type "bool".
391 // Make the named type "bool".
393 make_named_bool_type();
395 // Make an abstract integer type.
397 make_abstract_integer_type();
399 // Make a named integer type with a specified size.
400 // RUNTIME_TYPE_KIND is the code to use in reflection information,
401 // to distinguish int and int32.
403 make_integer_type(const char* name
, bool is_unsigned
, int bits
,
404 int runtime_type_kind
);
406 // Look up a named integer type.
408 lookup_integer_type(const char* name
);
410 // Make an abstract floating point type.
412 make_abstract_float_type();
414 // Make a named floating point type with a specific size.
415 // RUNTIME_TYPE_KIND is the code to use in reflection information,
416 // to distinguish float and float32.
418 make_float_type(const char* name
, int bits
, int runtime_type_kind
);
420 // Look up a named float type.
422 lookup_float_type(const char* name
);
424 // Make an abstract complex type.
426 make_abstract_complex_type();
428 // Make a named complex type with a specific size.
429 // RUNTIME_TYPE_KIND is the code to use in reflection information,
430 // to distinguish complex and complex64.
432 make_complex_type(const char* name
, int bits
, int runtime_type_kind
);
434 // Look up a named complex type.
436 lookup_complex_type(const char* name
);
438 // Get the unnamed string type.
442 // Get the named type "string".
444 lookup_string_type();
446 // Make the named type "string".
448 make_named_string_type();
453 static Function_type
*
454 make_function_type(Typed_identifier
* receiver
,
455 Typed_identifier_list
* parameters
,
456 Typed_identifier_list
* results
,
460 make_pointer_type(Type
*);
466 make_call_multiple_result_type(Call_expression
*);
469 make_struct_type(Struct_field_list
* fields
, source_location
);
472 make_array_type(Type
* element_type
, Expression
* length
);
475 make_map_type(Type
* key_type
, Type
* value_type
, source_location
);
478 make_channel_type(bool send
, bool receive
, Type
*);
480 static Interface_type
*
481 make_interface_type(Typed_identifier_list
* methods
, source_location
);
484 make_type_descriptor_type();
487 make_type_descriptor_ptr_type();
490 make_named_type(Named_object
*, Type
*, source_location
);
493 make_forward_declaration(Named_object
*);
497 traverse(Type
*, Traverse
*);
499 // Verify the type. This is called after parsing, and verifies that
500 // types are complete and meet the language requirements. This
501 // returns false if the type is invalid.
504 { return this->do_verify(); }
506 // Return true if two types are identical. If this returns false,
507 // and REASON is not NULL, it may set *REASON.
509 are_identical(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
511 // Return true if two types are compatible for use in a binary
512 // operation, other than a shift, comparison, or channel send. This
513 // is an equivalence relation.
515 are_compatible_for_binop(const Type
* t1
, const Type
* t2
);
517 // Return true if a value with type RHS is assignable to a variable
518 // with type LHS. This is not an equivalence relation. If this
519 // returns false, and REASON is not NULL, it sets *REASON.
521 are_assignable(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
523 // Return true if a value with type RHS may be converted to type
524 // LHS. If this returns false, and REASON is not NULL, it sets
527 are_convertible(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
529 // Whether this type has any hidden fields which are not visible in
530 // the current compilation, such as a field whose name begins with a
531 // lower case letter in a struct imported from a different package.
532 // WITHIN is not NULL if we are looking at fields in a named type.
534 has_hidden_fields(const Named_type
* within
, std::string
* reason
) const;
536 // Return a hash code for this type for the method hash table.
537 // Types which are equivalent according to are_identical will have
538 // the same hash code.
540 hash_for_method(Gogo
*) const;
542 // Return the type classification.
544 classification() const
545 { return this->classification_
; }
547 // Return the base type for this type. This looks through forward
548 // declarations and names. Using this with a forward declaration
549 // which has not been defined will return an error type.
556 // Return the type skipping defined forward declarations. If this
557 // type is a forward declaration which has not been defined, it will
558 // return the Forward_declaration_type. This differs from base() in
559 // that it will return a Named_type, and for a
560 // Forward_declaration_type which is not defined it will return that
561 // type rather than an error type.
568 // Return true if this is a basic type: a type which is not composed
569 // of other types, and is not void.
571 is_basic_type() const;
573 // Return true if this is an abstract type--an integer, floating
574 // point, or complex type whose size has not been determined.
578 // Return a non-abstract version of an abstract type.
580 make_non_abstract_type();
582 // Return true if this type is or contains a pointer. This
583 // determines whether the garbage collector needs to look at a value
587 { return this->do_has_pointer(); }
589 // Return true if this is an error type. An error type indicates a
592 is_error_type() const;
594 // Return true if this is a void type.
597 { return this->classification_
== TYPE_VOID
; }
599 // If this is an integer type, return the Integer_type. Otherwise,
600 // return NULL. This is a controlled dynamic_cast.
603 { return this->convert
<Integer_type
, TYPE_INTEGER
>(); }
607 { return this->convert
<const Integer_type
, TYPE_INTEGER
>(); }
609 // If this is a floating point type, return the Float_type.
610 // Otherwise, return NULL. This is a controlled dynamic_cast.
613 { return this->convert
<Float_type
, TYPE_FLOAT
>(); }
617 { return this->convert
<const Float_type
, TYPE_FLOAT
>(); }
619 // If this is a complex type, return the Complex_type. Otherwise,
623 { return this->convert
<Complex_type
, TYPE_COMPLEX
>(); }
627 { return this->convert
<const Complex_type
, TYPE_COMPLEX
>(); }
629 // Return true if this is a boolean type.
631 is_boolean_type() const
632 { return this->base()->classification_
== TYPE_BOOLEAN
; }
634 // Return true if this is an abstract boolean type.
636 is_abstract_boolean_type() const
637 { return this->classification_
== TYPE_BOOLEAN
; }
639 // Return true if this is a string type.
641 is_string_type() const
642 { return this->base()->classification_
== TYPE_STRING
; }
644 // Return true if this is an abstract string type.
646 is_abstract_string_type() const
647 { return this->classification_
== TYPE_STRING
; }
649 // Return true if this is the sink type. This is the type of the
650 // blank identifier _.
653 { return this->base()->classification_
== TYPE_SINK
; }
655 // If this is a function type, return it. Otherwise, return NULL.
658 { return this->convert
<Function_type
, TYPE_FUNCTION
>(); }
661 function_type() const
662 { return this->convert
<const Function_type
, TYPE_FUNCTION
>(); }
664 // If this is a pointer type, return the type to which it points.
665 // Otherwise, return NULL.
669 // If this is a pointer type, return the type to which it points.
670 // Otherwise, return the type itself.
674 Type
* pt
= this->points_to();
675 return pt
!= NULL
? pt
: this;
681 const Type
* pt
= this->points_to();
682 return pt
!= NULL
? pt
: this;
685 // Return true if this is the nil type. We don't use base() here,
686 // because this can be called during parse, and there is no way to
687 // name the nil type anyhow.
690 { return this->classification_
== TYPE_NIL
; }
692 // Return true if this is the predeclared constant nil being used as
693 // a type. This is what the parser produces for type switches which
696 is_nil_constant_as_type() const;
698 // Return true if this is the return type of a function which
699 // returns multiple values.
701 is_call_multiple_result_type() const
702 { return this->base()->classification_
== TYPE_CALL_MULTIPLE_RESULT
; }
704 // If this is a struct type, return it. Otherwise, return NULL.
707 { return this->convert
<Struct_type
, TYPE_STRUCT
>(); }
711 { return this->convert
<const Struct_type
, TYPE_STRUCT
>(); }
713 // If this is an array type, return it. Otherwise, return NULL.
716 { return this->convert
<Array_type
, TYPE_ARRAY
>(); }
720 { return this->convert
<const Array_type
, TYPE_ARRAY
>(); }
722 // Return whether if this is an open array type.
724 is_open_array_type() const;
726 // If this is a map type, return it. Otherwise, return NULL.
729 { return this->convert
<Map_type
, TYPE_MAP
>(); }
733 { return this->convert
<const Map_type
, TYPE_MAP
>(); }
735 // If this is a channel type, return it. Otherwise, return NULL.
738 { return this->convert
<Channel_type
, TYPE_CHANNEL
>(); }
742 { return this->convert
<const Channel_type
, TYPE_CHANNEL
>(); }
744 // If this is an interface type, return it. Otherwise, return NULL.
747 { return this->convert
<Interface_type
, TYPE_INTERFACE
>(); }
749 const Interface_type
*
750 interface_type() const
751 { return this->convert
<const Interface_type
, TYPE_INTERFACE
>(); }
753 // If this is a named type, return it. Otherwise, return NULL.
760 // If this is a forward declaration, return it. Otherwise, return
762 Forward_declaration_type
*
763 forward_declaration_type()
764 { return this->convert_no_base
<Forward_declaration_type
, TYPE_FORWARD
>(); }
766 const Forward_declaration_type
*
767 forward_declaration_type() const
769 return this->convert_no_base
<const Forward_declaration_type
,
773 // Return true if this type is not yet defined.
775 is_undefined() const;
777 // Return true if this is the unsafe.pointer type. We currently
778 // represent that as pointer-to-void.
780 is_unsafe_pointer_type() const
781 { return this->points_to() != NULL
&& this->points_to()->is_void_type(); }
783 // Look for field or method NAME for TYPE. Return an expression for
784 // it, bound to EXPR.
786 bind_field_or_method(Gogo
*, const Type
* type
, Expression
* expr
,
787 const std::string
& name
, source_location
);
789 // Return true if NAME is an unexported field or method of TYPE.
791 is_unexported_field_or_method(Gogo
*, const Type
*, const std::string
&);
793 // This type was passed to the builtin function make. ARGS are the
794 // arguments passed to make after the type; this may be NULL if
795 // there were none. Issue any required errors.
797 check_make_expression(Expression_list
* args
, source_location location
)
798 { return this->do_check_make_expression(args
, location
); }
800 // Return a tree representing this type.
804 // Return a tree representing a zero initialization for this type.
805 // This will be something like an INTEGER_CST or a CONSTRUCTOR. If
806 // IS_CLEAR is true, then the memory is known to be zeroed; in that
807 // case, this will return NULL if there is nothing to be done.
809 get_init_tree(Gogo
*, bool is_clear
);
811 // Like get_init_tree, but passing in the type to use for the
814 get_typed_init_tree(Gogo
* gogo
, tree type_tree
, bool is_clear
)
815 { return this->do_get_init_tree(gogo
, type_tree
, is_clear
); }
817 // Return a tree for a make expression applied to this type.
819 make_expression_tree(Translate_context
* context
, Expression_list
* args
,
820 source_location location
)
821 { return this->do_make_expression_tree(context
, args
, location
); }
823 // Build a type descriptor entry for this type. Return a pointer to
826 type_descriptor_pointer(Gogo
* gogo
);
828 // Return the type reflection string for this type.
830 reflection(Gogo
*) const;
832 // Return a mangled name for the type. This is a name which can be
833 // used in assembler code. Identical types should have the same
836 mangled_name(Gogo
*) const;
840 export_type(Export
* exp
) const
841 { this->do_export(exp
); }
845 import_type(Import
*);
848 Type(Type_classification
);
850 // Functions implemented by the child class.
852 // Traverse the subtypes.
854 do_traverse(Traverse
*);
862 do_has_pointer() const
866 do_hash_for_method(Gogo
*) const;
869 do_check_make_expression(Expression_list
* args
, source_location
);
873 do_get_tree(Gogo
*) = 0;
876 do_get_init_tree(Gogo
*, tree
, bool) = 0;
879 do_make_expression_tree(Translate_context
*, Expression_list
*,
883 do_type_descriptor(Gogo
*, Named_type
* name
) = 0;
886 do_reflection(Gogo
*, std::string
*) const = 0;
890 do_mangled_name(Gogo
*, std::string
*) const = 0;
893 do_export(Export
*) const;
895 // Return whether an expression is an integer.
897 check_int_value(Expression
*, const char*, source_location
);
899 // Return whether a method expects a pointer as the receiver.
901 method_expects_pointer(const Named_object
*);
903 // Finalize the methods for a type.
905 finalize_methods(Gogo
*, const Type
*, source_location
, Methods
**);
907 // Return a method from a set of methods.
909 method_function(const Methods
*, const std::string
& name
,
912 // Return a composite literal for the type descriptor entry for a
915 type_descriptor(Gogo
*, Type
*);
917 // Return a composite literal for the type descriptor entry for
918 // TYPE, using NAME as the name of the type.
920 named_type_descriptor(Gogo
*, Type
* type
, Named_type
* name
);
922 // Return a composite literal for a plain type descriptor for this
923 // type with the given kind and name.
925 plain_type_descriptor(Gogo
*, int runtime_type_kind
, Named_type
* name
);
927 // Build a composite literal for the basic type descriptor.
929 type_descriptor_constructor(Gogo
*, int runtime_type_kind
, Named_type
*,
930 const Methods
*, bool only_value_methods
);
932 // Make a builtin struct type from a list of fields.
934 make_builtin_struct_type(int nfields
, ...);
936 // Make a builtin named type.
938 make_builtin_named_type(const char* name
, Type
* type
);
940 // For the benefit of child class reflection string generation.
942 append_reflection(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
943 { type
->do_reflection(gogo
, ret
); }
945 // For the benefit of child class mangling.
947 append_mangled_name(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
948 { type
->do_mangled_name(gogo
, ret
); }
950 // Incorporate a string into a hash code.
952 hash_string(const std::string
&, unsigned int);
954 // Return a tree for the underlying type of a named type.
956 get_named_type_tree(Gogo
* gogo
, Type
* base_type
)
957 { return base_type
->get_tree_without_hash(gogo
); }
960 // Convert to the desired type classification, or return NULL. This
961 // is a controlled dynamic_cast.
962 template<typename Type_class
, Type_classification type_classification
>
966 Type
* base
= this->base();
967 return (base
->classification_
== type_classification
968 ? static_cast<Type_class
*>(base
)
972 template<typename Type_class
, Type_classification type_classification
>
976 const Type
* base
= this->base();
977 return (base
->classification_
== type_classification
978 ? static_cast<Type_class
*>(base
)
982 template<typename Type_class
, Type_classification type_classification
>
986 return (this->classification_
== type_classification
987 ? static_cast<Type_class
*>(this)
991 template<typename Type_class
, Type_classification type_classification
>
993 convert_no_base() const
995 return (this->classification_
== type_classification
996 ? static_cast<Type_class
*>(this)
1000 // Get the hash and equality functions for a type.
1002 type_functions(const char** hash_fn
, const char** equal_fn
) const;
1004 // Build a composite literal for the uncommon type information.
1006 uncommon_type_constructor(Gogo
*, Type
* uncommon_type
,
1007 Named_type
*, const Methods
*,
1008 bool only_value_methods
) const;
1010 // Build a composite literal for the methods.
1012 methods_constructor(Gogo
*, Type
* methods_type
, const Methods
*,
1013 bool only_value_methods
) const;
1015 // Build a composite literal for one method.
1017 method_constructor(Gogo
*, Type
* method_type
, const std::string
& name
,
1018 const Method
*) const;
1021 build_receive_return_type(tree type
);
1023 // A hash table we use to avoid infinite recursion.
1024 typedef Unordered_set_hash(const Named_type
*, Type_hash_identical
,
1025 Type_identical
) Types_seen
;
1027 // Add all methods for TYPE to the list of methods for THIS.
1029 add_methods_for_type(const Type
* type
, const Method::Field_indexes
*,
1030 unsigned int depth
, bool, bool, Types_seen
*,
1034 add_local_methods_for_type(const Named_type
* type
,
1035 const Method::Field_indexes
*,
1036 unsigned int depth
, bool, bool, Methods
**);
1039 add_embedded_methods_for_type(const Type
* type
,
1040 const Method::Field_indexes
*,
1041 unsigned int depth
, bool, bool, Types_seen
*,
1045 add_interface_methods_for_type(const Type
* type
,
1046 const Method::Field_indexes
*,
1047 unsigned int depth
, Methods
**);
1049 // Build stub methods for a type.
1051 build_stub_methods(Gogo
*, const Type
* type
, const Methods
* methods
,
1055 build_one_stub_method(Gogo
*, Method
*, const char* receiver_name
,
1056 const Typed_identifier_list
*, bool is_varargs
,
1060 apply_field_indexes(Expression
*, const Method::Field_indexes
*,
1063 // Look for a field or method named NAME in TYPE.
1065 find_field_or_method(const Type
* type
, const std::string
& name
,
1066 bool receiver_can_be_pointer
,
1067 int* level
, bool* is_method
,
1068 bool* found_pointer_method
,
1069 std::string
* ambig1
, std::string
* ambig2
);
1071 // Get a tree for a type without looking in the hash table for
1074 get_tree_without_hash(Gogo
*);
1076 // A mapping from Type to tree, used to ensure that the GIMPLE
1077 // representation of identical types is identical.
1078 typedef Unordered_map_hash(const Type
*, tree
, Type_hash_identical
,
1079 Type_identical
) Type_trees
;
1081 static Type_trees type_trees
;
1083 // The type classification.
1084 Type_classification classification_
;
1085 // The tree representation of the type, once it has been determined.
1087 // The decl for the type descriptor for this type. This starts out
1088 // as NULL and is filled in as needed.
1089 tree type_descriptor_decl_
;
1092 // Type hash table operations.
1094 class Type_hash_identical
1098 operator()(const Type
* type
) const
1099 { return type
->hash_for_method(NULL
); }
1102 class Type_identical
1106 operator()(const Type
* t1
, const Type
* t2
) const
1107 { return Type::are_identical(t1
, t2
, NULL
); }
1110 // An identifier with a type.
1112 class Typed_identifier
1115 Typed_identifier(const std::string
& name
, Type
* type
,
1116 source_location location
)
1117 : name_(name
), type_(type
), location_(location
)
1123 { return this->name_
; }
1128 { return this->type_
; }
1130 // Return the location where the name was seen. This is not always
1134 { return this->location_
; }
1136 // Set the type--sometimes we see the identifier before the type.
1138 set_type(Type
* type
)
1140 gcc_assert(this->type_
== NULL
|| type
->is_error_type());
1149 // The location where the name was seen.
1150 source_location location_
;
1153 // A list of Typed_identifiers.
1155 class Typed_identifier_list
1158 Typed_identifier_list()
1162 // Whether the list is empty.
1165 { return this->entries_
.empty(); }
1167 // Return the number of entries in the list.
1170 { return this->entries_
.size(); }
1172 // Add an entry to the end of the list.
1174 push_back(const Typed_identifier
& td
)
1175 { this->entries_
.push_back(td
); }
1177 // Remove an entry from the end of the list.
1180 { this->entries_
.pop_back(); }
1182 // Set the type of entry I to TYPE.
1184 set_type(size_t i
, Type
* type
)
1186 gcc_assert(i
< this->entries_
.size());
1187 this->entries_
[i
].set_type(type
);
1190 // Sort the entries by name.
1196 traverse(Traverse
*);
1198 // Return the first and last elements.
1201 { return this->entries_
.front(); }
1203 const Typed_identifier
&
1205 { return this->entries_
.front(); }
1209 { return this->entries_
.back(); }
1211 const Typed_identifier
&
1213 { return this->entries_
.back(); }
1215 const Typed_identifier
&
1217 { return this->entries_
.at(i
); }
1220 set(size_t i
, const Typed_identifier
& t
)
1221 { this->entries_
.at(i
) = t
; }
1226 gcc_assert(c
<= this->entries_
.size());
1227 this->entries_
.resize(c
, Typed_identifier("", NULL
, UNKNOWN_LOCATION
));
1232 typedef std::vector
<Typed_identifier
>::iterator iterator
;
1233 typedef std::vector
<Typed_identifier
>::const_iterator const_iterator
;
1237 { return this->entries_
.begin(); }
1241 { return this->entries_
.begin(); }
1245 { return this->entries_
.end(); }
1249 { return this->entries_
.end(); }
1251 // Return a copy of this list. This returns an independent copy of
1252 // the vector, but does not copy the types.
1253 Typed_identifier_list
*
1257 std::vector
<Typed_identifier
> entries_
;
1260 // The type of an integer.
1262 class Integer_type
: public Type
1265 // Create a new integer type.
1267 create_integer_type(const char* name
, bool is_unsigned
, int bits
,
1268 int runtime_type_kind
);
1270 // Look up an existing integer type.
1272 lookup_integer_type(const char* name
);
1274 // Create an abstract integer type.
1275 static Integer_type
*
1276 create_abstract_integer_type();
1278 // Whether this is an abstract integer type.
1281 { return this->is_abstract_
; }
1283 // Whether this is an unsigned type.
1286 { return this->is_unsigned_
; }
1288 // The number of bits.
1291 { return this->bits_
; }
1293 // Whether this type is the same as T.
1295 is_identical(const Integer_type
* t
) const;
1299 do_hash_for_method(Gogo
*) const;
1305 do_get_init_tree(Gogo
*, tree
, bool);
1308 do_type_descriptor(Gogo
*, Named_type
*);
1311 do_reflection(Gogo
*, std::string
*) const;
1314 do_mangled_name(Gogo
*, std::string
*) const;
1317 Integer_type(bool is_abstract
, bool is_unsigned
, int bits
,
1318 int runtime_type_kind
)
1319 : Type(TYPE_INTEGER
),
1320 is_abstract_(is_abstract
), is_unsigned_(is_unsigned
), bits_(bits
),
1321 runtime_type_kind_(runtime_type_kind
)
1324 // Map names of integer types to the types themselves.
1325 typedef std::map
<std::string
, Named_type
*> Named_integer_types
;
1326 static Named_integer_types named_integer_types
;
1328 // True if this is an abstract type.
1330 // True if this is an unsigned type.
1332 // The number of bits.
1334 // The runtime type code used in the type descriptor for this type.
1335 int runtime_type_kind_
;
1338 // The type of a floating point number.
1340 class Float_type
: public Type
1343 // Create a new float type.
1345 create_float_type(const char* name
, int bits
, int runtime_type_kind
);
1347 // Look up an existing float type.
1349 lookup_float_type(const char* name
);
1351 // Create an abstract float type.
1353 create_abstract_float_type();
1355 // Whether this is an abstract float type.
1358 { return this->is_abstract_
; }
1360 // The number of bits.
1363 { return this->bits_
; }
1365 // Whether this type is the same as T.
1367 is_identical(const Float_type
* t
) const;
1369 // Return a tree for this type without using a Gogo*.
1375 do_hash_for_method(Gogo
*) const;
1381 do_get_init_tree(Gogo
*, tree
, bool);
1384 do_type_descriptor(Gogo
*, Named_type
*);
1387 do_reflection(Gogo
*, std::string
*) const;
1390 do_mangled_name(Gogo
*, std::string
*) const;
1393 Float_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1395 is_abstract_(is_abstract
), bits_(bits
),
1396 runtime_type_kind_(runtime_type_kind
)
1399 // Map names of float types to the types themselves.
1400 typedef std::map
<std::string
, Named_type
*> Named_float_types
;
1401 static Named_float_types named_float_types
;
1403 // True if this is an abstract type.
1405 // The number of bits in the floating point value.
1407 // The runtime type code used in the type descriptor for this type.
1408 int runtime_type_kind_
;
1411 // The type of a complex number.
1413 class Complex_type
: public Type
1416 // Create a new complex type.
1418 create_complex_type(const char* name
, int bits
, int runtime_type_kind
);
1420 // Look up an existing complex type.
1422 lookup_complex_type(const char* name
);
1424 // Create an abstract complex type.
1425 static Complex_type
*
1426 create_abstract_complex_type();
1428 // Whether this is an abstract complex type.
1431 { return this->is_abstract_
; }
1433 // The number of bits: 64 or 128.
1435 { return this->bits_
; }
1437 // Whether this type is the same as T.
1439 is_identical(const Complex_type
* t
) const;
1441 // Return a tree for this type without using a Gogo*.
1447 do_hash_for_method(Gogo
*) const;
1453 do_get_init_tree(Gogo
*, tree
, bool);
1456 do_type_descriptor(Gogo
*, Named_type
*);
1459 do_reflection(Gogo
*, std::string
*) const;
1462 do_mangled_name(Gogo
*, std::string
*) const;
1465 Complex_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1466 : Type(TYPE_COMPLEX
),
1467 is_abstract_(is_abstract
), bits_(bits
),
1468 runtime_type_kind_(runtime_type_kind
)
1471 // Map names of complex types to the types themselves.
1472 typedef std::map
<std::string
, Named_type
*> Named_complex_types
;
1473 static Named_complex_types named_complex_types
;
1475 // True if this is an abstract type.
1477 // The number of bits in the complex value--64 or 128.
1479 // The runtime type code used in the type descriptor for this type.
1480 int runtime_type_kind_
;
1483 // The type of a string.
1485 class String_type
: public Type
1492 // Return a tree for the length of STRING.
1494 length_tree(Gogo
*, tree string
);
1496 // Return a tree which points to the bytes of STRING.
1498 bytes_tree(Gogo
*, tree string
);
1502 do_has_pointer() const
1509 do_get_init_tree(Gogo
* gogo
, tree
, bool);
1512 do_type_descriptor(Gogo
*, Named_type
*);
1515 do_reflection(Gogo
*, std::string
*) const;
1518 do_mangled_name(Gogo
*, std::string
* ret
) const;
1521 // The named string type.
1522 static Named_type
* string_type_
;
1525 // The type of a function.
1527 class Function_type
: public Type
1530 Function_type(Typed_identifier
* receiver
, Typed_identifier_list
* parameters
,
1531 Typed_identifier_list
* results
, source_location location
)
1532 : Type(TYPE_FUNCTION
),
1533 receiver_(receiver
), parameters_(parameters
), results_(results
),
1534 location_(location
), is_varargs_(false), is_builtin_(false)
1537 // Get the receiver.
1538 const Typed_identifier
*
1540 { return this->receiver_
; }
1542 // Get the return names and types.
1543 const Typed_identifier_list
*
1545 { return this->results_
; }
1547 // Get the parameter names and types.
1548 const Typed_identifier_list
*
1550 { return this->parameters_
; }
1552 // Whether this is a varargs function.
1555 { return this->is_varargs_
; }
1557 // Whether this is a builtin function.
1560 { return this->is_builtin_
; }
1562 // The location where this type was defined.
1565 { return this->location_
; }
1567 // Return whether this is a method type.
1570 { return this->receiver_
!= NULL
; }
1572 // Whether T is a valid redeclaration of this type. This is called
1573 // when a function is declared more than once.
1575 is_valid_redeclaration(const Function_type
* t
, std::string
*) const;
1577 // Whether this type is the same as T.
1579 is_identical(const Function_type
* t
, bool ignore_receiver
,
1580 std::string
*) const;
1582 // Record that this is a varargs function.
1585 { this->is_varargs_
= true; }
1587 // Record that this is a builtin function.
1590 { this->is_builtin_
= true; }
1592 // Import a function type.
1593 static Function_type
*
1596 // Return a copy of this type without a receiver. This is only
1597 // valid for a method type.
1599 copy_without_receiver() const;
1601 // Return a copy of this type with a receiver. This is used when an
1602 // interface method is attached to a named or struct type.
1604 copy_with_receiver(Type
*) const;
1608 do_traverse(Traverse
*);
1610 // A trampoline function has a pointer which matters for GC.
1612 do_has_pointer() const
1616 do_hash_for_method(Gogo
*) const;
1622 do_get_init_tree(Gogo
*, tree
, bool);
1625 do_type_descriptor(Gogo
*, Named_type
*);
1628 do_reflection(Gogo
*, std::string
*) const;
1631 do_mangled_name(Gogo
*, std::string
*) const;
1634 do_export(Export
*) const;
1638 make_function_type_descriptor_type();
1641 type_descriptor_params(Type
*, const Typed_identifier
*,
1642 const Typed_identifier_list
*);
1644 // The receiver name and type. This will be NULL for a normal
1645 // function, non-NULL for a method.
1646 Typed_identifier
* receiver_
;
1647 // The parameter names and types.
1648 Typed_identifier_list
* parameters_
;
1649 // The result names and types. This will be NULL if no result was
1651 Typed_identifier_list
* results_
;
1652 // The location where this type was defined. This exists solely to
1653 // give a location for the fields of the struct if this function
1654 // returns multiple values.
1655 source_location location_
;
1656 // Whether this function takes a variable number of arguments.
1658 // Whether this is a special builtin function which can not simply
1659 // be called. This is used for len, cap, etc.
1663 // The type of a pointer.
1665 class Pointer_type
: public Type
1668 Pointer_type(Type
* to_type
)
1669 : Type(TYPE_POINTER
),
1675 { return this->to_type_
; }
1677 // Import a pointer type.
1678 static Pointer_type
*
1683 do_traverse(Traverse
*);
1686 do_has_pointer() const
1690 do_hash_for_method(Gogo
*) const;
1696 do_get_init_tree(Gogo
*, tree
, bool);
1699 do_type_descriptor(Gogo
*, Named_type
*);
1702 do_reflection(Gogo
*, std::string
*) const;
1705 do_mangled_name(Gogo
*, std::string
*) const;
1708 do_export(Export
*) const;
1712 make_pointer_type_descriptor_type();
1714 // The type to which this type points.
1718 // The type of a field in a struct.
1723 explicit Struct_field(const Typed_identifier
& typed_identifier
)
1724 : typed_identifier_(typed_identifier
), tag_(NULL
)
1734 { return this->typed_identifier_
.type(); }
1736 // The field location.
1739 { return this->typed_identifier_
.location(); }
1741 // Whether the field has a tag.
1744 { return this->tag_
!= NULL
; }
1750 gcc_assert(this->tag_
!= NULL
);
1754 // Whether this is an anonymous field.
1756 is_anonymous() const
1757 { return this->typed_identifier_
.name().empty(); }
1759 // Set the tag. FIXME: This is never freed.
1761 set_tag(const std::string
& tag
)
1762 { this->tag_
= new std::string(tag
); }
1764 // Set the type. This is only used in error cases.
1766 set_type(Type
* type
)
1767 { this->typed_identifier_
.set_type(type
); }
1770 // The field name, type, and location.
1771 Typed_identifier typed_identifier_
;
1772 // The field tag. This is NULL if the field has no tag.
1776 // A list of struct fields.
1778 class Struct_field_list
1785 // Whether the list is empty.
1788 { return this->entries_
.empty(); }
1790 // Return the number of entries.
1793 { return this->entries_
.size(); }
1795 // Add an entry to the end of the list.
1797 push_back(const Struct_field
& sf
)
1798 { this->entries_
.push_back(sf
); }
1800 // Index into the list.
1803 { return this->entries_
.at(i
); }
1805 // Last entry in list.
1808 { return this->entries_
.back(); }
1812 typedef std::vector
<Struct_field
>::iterator iterator
;
1813 typedef std::vector
<Struct_field
>::const_iterator const_iterator
;
1817 { return this->entries_
.begin(); }
1821 { return this->entries_
.begin(); }
1825 { return this->entries_
.end(); }
1829 { return this->entries_
.end(); }
1832 std::vector
<Struct_field
> entries_
;
1835 // The type of a struct.
1837 class Struct_type
: public Type
1840 Struct_type(Struct_field_list
* fields
, source_location location
)
1841 : Type(TYPE_STRUCT
),
1842 fields_(fields
), location_(location
), all_methods_(NULL
)
1845 // Return the field NAME. This only looks at local fields, not at
1846 // embedded types. If the field is found, and PINDEX is not NULL,
1847 // this sets *PINDEX to the field index. If the field is not found,
1848 // this returns NULL.
1850 find_local_field(const std::string
& name
, unsigned int *pindex
) const;
1852 // Return the field number INDEX.
1854 field(unsigned int index
) const
1855 { return &this->fields_
->at(index
); }
1857 // Get the struct fields.
1858 const Struct_field_list
*
1860 { return this->fields_
; }
1862 // Return the number of fields.
1865 { return this->fields_
->size(); }
1867 // Push a new field onto the end of the struct. This is used when
1868 // building a closure variable.
1870 push_field(const Struct_field
& sf
)
1871 { this->fields_
->push_back(sf
); }
1873 // Return an expression referring to field NAME in STRUCT_EXPR, or
1874 // NULL if there is no field with that name.
1875 Field_reference_expression
*
1876 field_reference(Expression
* struct_expr
, const std::string
& name
,
1877 source_location
) const;
1879 // Return the total number of fields, including embedded fields.
1880 // This is the number of values which can appear in a conversion to
1883 total_field_count() const;
1885 // Whether this type is identical with T.
1887 is_identical(const Struct_type
* t
) const;
1889 // Whether this struct type has any hidden fields. This returns
1890 // true if any fields have hidden names, or if any non-pointer
1891 // anonymous fields have types with hidden fields.
1893 struct_has_hidden_fields(const Named_type
* within
, std::string
*) const;
1895 // Return whether NAME is a local field which is not exported. This
1896 // is only used for better error reporting.
1898 is_unexported_local_field(Gogo
*, const std::string
& name
) const;
1900 // If this is an unnamed struct, build the complete list of methods,
1901 // including those from anonymous fields, and build methods stubs if
1904 finalize_methods(Gogo
*);
1906 // Return whether this type has any methods. This should only be
1907 // called after the finalize_methods pass.
1909 has_any_methods() const
1910 { return this->all_methods_
!= NULL
; }
1912 // Return the methods for tihs type. This should only be called
1913 // after the finalize_methods pass.
1916 { return this->all_methods_
; }
1918 // Return the method to use for NAME. This returns NULL if there is
1919 // no such method or if the method is ambiguous. When it returns
1920 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
1922 method_function(const std::string
& name
, bool* is_ambiguous
) const;
1924 // Traverse just the field types of a struct type.
1926 traverse_field_types(Traverse
* traverse
)
1927 { return this->do_traverse(traverse
); }
1929 // Import a struct type.
1933 // Fill in the fields for a named struct type.
1935 fill_in_tree(Gogo
*, tree
);
1939 do_traverse(Traverse
*);
1945 do_has_pointer() const;
1948 do_hash_for_method(Gogo
*) const;
1954 do_get_init_tree(Gogo
*, tree
, bool);
1957 do_type_descriptor(Gogo
*, Named_type
*);
1960 do_reflection(Gogo
*, std::string
*) const;
1963 do_mangled_name(Gogo
*, std::string
*) const;
1966 do_export(Export
*) const;
1969 Field_reference_expression
*
1970 field_reference_depth(Expression
* struct_expr
, const std::string
& name
,
1971 source_location
, unsigned int* depth
) const;
1974 make_struct_type_descriptor_type();
1976 // The fields of the struct.
1977 Struct_field_list
* fields_
;
1978 // The place where the struct was declared.
1979 source_location location_
;
1980 // If this struct is unnamed, a list of methods.
1981 Methods
* all_methods_
;
1984 // The type of an array.
1986 class Array_type
: public Type
1989 Array_type(Type
* element_type
, Expression
* length
)
1991 element_type_(element_type
), length_(length
), length_tree_(NULL
)
1994 // Return the element type.
1996 element_type() const
1997 { return this->element_type_
; }
1999 // Return the length. This will return NULL for an open array.
2002 { return this->length_
; }
2004 // Whether this type is identical with T.
2006 is_identical(const Array_type
* t
) const;
2008 // Whether this type has any hidden fields.
2010 array_has_hidden_fields(const Named_type
* within
, std::string
* reason
) const
2011 { return this->element_type_
->has_hidden_fields(within
, reason
); }
2013 // Return a tree for the pointer to the values in an array.
2015 value_pointer_tree(Gogo
*, tree array
) const;
2017 // Return a tree for the length of an array with this type.
2019 length_tree(Gogo
*, tree array
);
2021 // Return a tree for the capacity of an array with this type.
2023 capacity_tree(Gogo
*, tree array
);
2025 // Import an array type.
2029 // Fill in the fields for a named slice type.
2031 fill_in_tree(Gogo
*, tree
);
2035 do_traverse(Traverse
* traverse
);
2041 do_has_pointer() const
2043 return this->length_
== NULL
|| this->element_type_
->has_pointer();
2047 do_hash_for_method(Gogo
*) const;
2050 do_check_make_expression(Expression_list
*, source_location
);
2056 do_get_init_tree(Gogo
*, tree
, bool);
2059 do_make_expression_tree(Translate_context
*, Expression_list
*,
2063 do_type_descriptor(Gogo
*, Named_type
*);
2066 do_reflection(Gogo
*, std::string
*) const;
2069 do_mangled_name(Gogo
*, std::string
*) const;
2072 do_export(Export
*) const;
2079 get_length_tree(Gogo
*);
2082 make_array_type_descriptor_type();
2085 make_slice_type_descriptor_type();
2088 array_type_descriptor(Gogo
*, Named_type
*);
2091 slice_type_descriptor(Gogo
*, Named_type
*);
2093 // The type of elements of the array.
2094 Type
* element_type_
;
2095 // The number of elements. This may be NULL.
2096 Expression
* length_
;
2097 // The length as a tree. We only want to compute this once.
2101 // The type of a map.
2103 class Map_type
: public Type
2106 Map_type(Type
* key_type
, Type
* val_type
, source_location location
)
2108 key_type_(key_type
), val_type_(val_type
), location_(location
)
2111 // Return the key type.
2114 { return this->key_type_
; }
2116 // Return the value type.
2119 { return this->val_type_
; }
2121 // Whether this type is identical with T.
2123 is_identical(const Map_type
* t
) const;
2125 // Import a map type.
2131 do_traverse(Traverse
*);
2137 do_has_pointer() const
2141 do_hash_for_method(Gogo
*) const;
2144 do_check_make_expression(Expression_list
*, source_location
);
2150 do_get_init_tree(Gogo
*, tree
, bool);
2153 do_make_expression_tree(Translate_context
*, Expression_list
*,
2157 do_type_descriptor(Gogo
*, Named_type
*);
2160 do_reflection(Gogo
*, std::string
*) const;
2163 do_mangled_name(Gogo
*, std::string
*) const;
2166 do_export(Export
*) const;
2170 make_map_type_descriptor_type();
2176 // Where the type was defined.
2177 source_location location_
;
2180 // The type of a channel.
2182 class Channel_type
: public Type
2185 Channel_type(bool may_send
, bool may_receive
, Type
* element_type
)
2186 : Type(TYPE_CHANNEL
),
2187 may_send_(may_send
), may_receive_(may_receive
),
2188 element_type_(element_type
)
2189 { gcc_assert(may_send
|| may_receive
); }
2191 // Whether this channel can send data.
2194 { return this->may_send_
; }
2196 // Whether this channel can receive data.
2199 { return this->may_receive_
; }
2201 // The type of the values that may be sent on this channel. This is
2202 // NULL if any type may be sent.
2204 element_type() const
2205 { return this->element_type_
; }
2207 // Whether this type is identical with T.
2209 is_identical(const Channel_type
* t
) const;
2211 // Import a channel type.
2212 static Channel_type
*
2217 do_traverse(Traverse
* traverse
)
2218 { return Type::traverse(this->element_type_
, traverse
); }
2221 do_has_pointer() const
2225 do_hash_for_method(Gogo
*) const;
2228 do_check_make_expression(Expression_list
*, source_location
);
2234 do_get_init_tree(Gogo
*, tree
, bool);
2237 do_make_expression_tree(Translate_context
*, Expression_list
*,
2241 do_type_descriptor(Gogo
*, Named_type
*);
2244 do_reflection(Gogo
*, std::string
*) const;
2247 do_mangled_name(Gogo
*, std::string
*) const;
2250 do_export(Export
*) const;
2254 make_chan_type_descriptor_type();
2256 // Whether this channel can send data.
2258 // Whether this channel can receive data.
2260 // The types of elements which may be sent on this channel. If this
2261 // is NULL, it means that any type may be sent.
2262 Type
* element_type_
;
2265 // An interface type.
2267 class Interface_type
: public Type
2270 Interface_type(Typed_identifier_list
* methods
, source_location location
)
2271 : Type(TYPE_INTERFACE
),
2272 methods_(methods
), location_(location
)
2273 { gcc_assert(methods
== NULL
|| !methods
->empty()); }
2275 // Return whether this is an empty interface.
2278 { return this->methods_
== NULL
; }
2280 // Return the list of methods. This will return NULL for an empty
2282 const Typed_identifier_list
*
2284 { return this->methods_
; }
2286 // Return the number of methods.
2288 method_count() const
2289 { return this->methods_
== NULL
? 0 : this->methods_
->size(); }
2291 // Return the method NAME, or NULL.
2292 const Typed_identifier
*
2293 find_method(const std::string
& name
) const;
2295 // Return the zero-based index of method NAME.
2297 method_index(const std::string
& name
) const;
2299 // Finalize the methods. This handles interface inheritance.
2303 // Return true if T implements this interface. If this returns
2304 // false, and REASON is not NULL, it sets *REASON to the reason that
2307 implements_interface(const Type
* t
, std::string
* reason
) const;
2309 // Whether this type is identical with T. REASON is as in
2310 // implements_interface.
2312 is_identical(const Interface_type
* t
) const;
2314 // Whether we can assign T to this type. is_identical is known to
2317 is_compatible_for_assign(const Interface_type
*, std::string
* reason
) const;
2319 // Return whether NAME is a method which is not exported. This is
2320 // only used for better error reporting.
2322 is_unexported_method(Gogo
*, const std::string
& name
) const;
2324 // Import an interface type.
2325 static Interface_type
*
2328 // Fill in the fields for a named interface type.
2330 fill_in_tree(Gogo
*, tree
);
2334 do_traverse(Traverse
*);
2337 do_has_pointer() const
2341 do_hash_for_method(Gogo
*) const;
2347 do_get_init_tree(Gogo
* gogo
, tree
, bool);
2350 do_type_descriptor(Gogo
*, Named_type
*);
2353 do_reflection(Gogo
*, std::string
*) const;
2356 do_mangled_name(Gogo
*, std::string
*) const;
2359 do_export(Export
*) const;
2363 make_interface_type_descriptor_type();
2365 // The list of methods associated with the interface. This will be
2366 // NULL for the empty interface.
2367 Typed_identifier_list
* methods_
;
2368 // The location where the interface was defined.
2369 source_location location_
;
2372 // The value we keep for a named type. This lets us get the right
2373 // name when we convert to trees. Note that we don't actually keep
2374 // the name here; the name is in the Named_object which points to
2375 // this. This object exists to hold a unique tree which represents
2378 class Named_type
: public Type
2381 Named_type(Named_object
* named_object
, Type
* type
, source_location location
)
2383 named_object_(named_object
), in_function_(NULL
), type_(type
),
2384 local_methods_(NULL
), all_methods_(NULL
),
2385 interface_method_tables_(NULL
), pointer_interface_method_tables_(NULL
),
2386 location_(location
), named_tree_(NULL
), is_visible_(true),
2387 is_error_(false), seen_(false)
2390 // Return the associated Named_object. This holds the actual name.
2393 { return this->named_object_
; }
2396 named_object() const
2397 { return this->named_object_
; }
2399 // Set the Named_object. This is used when we see a type
2400 // declaration followed by a type.
2402 set_named_object(Named_object
* no
)
2403 { this->named_object_
= no
; }
2405 // Return the function in which this type is defined. This will
2406 // return NULL for a type defined in global scope.
2409 { return this->in_function_
; }
2411 // Set the function in which this type is defined.
2413 set_in_function(Named_object
* f
)
2414 { this->in_function_
= f
; }
2416 // Return the name of the type.
2420 // Return the name of the type for an error message. The difference
2421 // is that if the type is defined in a different package, this will
2422 // return PACKAGE.NAME.
2424 message_name() const;
2426 // Return the underlying type.
2429 { return this->type_
; }
2433 { return this->type_
; }
2435 // Return the location.
2438 { return this->location_
; }
2440 // Whether this type is visible. This only matters when parsing.
2443 { return this->is_visible_
; }
2445 // Mark this type as visible.
2448 { this->is_visible_
= true; }
2450 // Mark this type as invisible.
2453 { this->is_visible_
= false; }
2455 // Whether this is a builtin type.
2458 { return this->location_
== BUILTINS_LOCATION
; }
2460 // Add a method to this type.
2462 add_method(const std::string
& name
, Function
*);
2464 // Add a method declaration to this type.
2466 add_method_declaration(const std::string
& name
, Package
* package
,
2467 Function_type
* type
, source_location location
);
2469 // Add an existing method--one defined before the type itself was
2470 // defined--to a type.
2472 add_existing_method(Named_object
*);
2474 // Look up a local method.
2476 find_local_method(const std::string
& name
) const;
2478 // Return the list of local methods.
2480 local_methods() const
2481 { return this->local_methods_
; }
2483 // Build the complete list of methods, including those from
2484 // anonymous fields, and build method stubs if needed.
2486 finalize_methods(Gogo
*);
2488 // Return whether this type has any methods. This should only be
2489 // called after the finalize_methods pass.
2491 has_any_methods() const
2492 { return this->all_methods_
!= NULL
; }
2494 // Return the methods for this type. This should only be called
2495 // after the finalized_methods pass.
2498 { return this->all_methods_
; }
2500 // Return the method to use for NAME. This returns NULL if there is
2501 // no such method or if the method is ambiguous. When it returns
2502 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2504 method_function(const std::string
& name
, bool *is_ambiguous
) const;
2506 // Return whether NAME is a known field or method which is not
2507 // exported. This is only used for better error reporting.
2509 is_unexported_local_method(Gogo
*, const std::string
& name
) const;
2511 // Return a pointer to the interface method table for this type for
2512 // the interface INTERFACE. If IS_POINTER is true, set the type
2513 // descriptor to a pointer to this type, otherwise set it to this
2516 interface_method_table(Gogo
*, const Interface_type
* interface
,
2519 // Whether this type has any hidden fields.
2521 named_type_has_hidden_fields(std::string
* reason
) const;
2525 export_named_type(Export
*, const std::string
& name
) const;
2527 // Import a named type.
2529 import_named_type(Import
*, Named_type
**);
2533 do_traverse(Traverse
* traverse
)
2534 { return Type::traverse(this->type_
, traverse
); }
2540 do_has_pointer() const
2541 { return this->type_
->has_pointer(); }
2544 do_hash_for_method(Gogo
*) const;
2547 do_check_make_expression(Expression_list
* args
, source_location location
)
2548 { return this->type_
->check_make_expression(args
, location
); }
2554 do_get_init_tree(Gogo
* gogo
, tree type_tree
, bool is_clear
)
2555 { return this->type_
->get_typed_init_tree(gogo
, type_tree
, is_clear
); }
2558 do_make_expression_tree(Translate_context
* context
, Expression_list
* args
,
2559 source_location location
)
2560 { return this->type_
->make_expression_tree(context
, args
, location
); }
2563 do_type_descriptor(Gogo
*, Named_type
*);
2566 do_reflection(Gogo
*, std::string
*) const;
2569 do_mangled_name(Gogo
*, std::string
* ret
) const;
2572 do_export(Export
*) const;
2575 // A mapping from interfaces to the associated interface method
2576 // tables for this type. This maps to a decl.
2577 typedef Unordered_map_hash(const Interface_type
*, tree
, Type_hash_identical
,
2578 Type_identical
) Interface_method_tables
;
2580 // A pointer back to the Named_object for this type.
2581 Named_object
* named_object_
;
2582 // If this type is defined in a function, a pointer back to the
2583 // function in which it is defined.
2584 Named_object
* in_function_
;
2587 // The list of methods defined for this type. Any named type can
2589 Bindings
* local_methods_
;
2590 // The full list of methods for this type, including methods
2591 // declared for anonymous fields.
2592 Methods
* all_methods_
;
2593 // A mapping from interfaces to the associated interface method
2594 // tables for this type.
2595 Interface_method_tables
* interface_method_tables_
;
2596 // A mapping from interfaces to the associated interface method
2597 // tables for pointers to this type.
2598 Interface_method_tables
* pointer_interface_method_tables_
;
2599 // The location where this type was defined.
2600 source_location location_
;
2601 // The tree for this type while converting to GENERIC. This is used
2602 // to avoid endless recursion when a named type refers to itself.
2604 // Whether this type is visible. This is false if this type was
2605 // created because it was referenced by an imported object, but the
2606 // type itself was not exported. This will always be true for types
2607 // created in the current package.
2609 // Whether this type is erroneous.
2611 // In a recursive operation such as has_hidden_fields, this flag is
2612 // used to prevent infinite recursion when a type refers to itself.
2613 // This is mutable because it is always reset to false when the
2618 // A forward declaration. This handles a type which has been declared
2621 class Forward_declaration_type
: public Type
2624 Forward_declaration_type(Named_object
* named_object
);
2626 // The named object associated with this type declaration. This
2627 // will be resolved.
2632 named_object() const;
2634 // Return the name of the type.
2638 // Return the type to which this points. Give an error if the type
2639 // has not yet been defined.
2646 // Whether the base type has been defined.
2650 // Add a method to this type.
2652 add_method(const std::string
& name
, Function
*);
2654 // Add a method declaration to this type.
2656 add_method_declaration(const std::string
& name
, Function_type
*,
2661 do_traverse(Traverse
* traverse
);
2664 do_has_pointer() const
2665 { return this->base()->has_pointer(); }
2668 do_hash_for_method(Gogo
* gogo
) const
2669 { return this->real_type()->hash_for_method(gogo
); }
2672 do_check_make_expression(Expression_list
* args
, source_location location
)
2673 { return this->base()->check_make_expression(args
, location
); }
2676 do_get_tree(Gogo
* gogo
);
2679 do_get_init_tree(Gogo
* gogo
, tree type_tree
, bool is_clear
)
2680 { return this->base()->get_typed_init_tree(gogo
, type_tree
, is_clear
); }
2683 do_make_expression_tree(Translate_context
* context
, Expression_list
* args
,
2684 source_location location
)
2685 { return this->base()->make_expression_tree(context
, args
, location
); }
2688 do_type_descriptor(Gogo
*, Named_type
*);
2691 do_reflection(Gogo
*, std::string
*) const;
2694 do_mangled_name(Gogo
*, std::string
* ret
) const;
2697 do_export(Export
*) const;
2700 // Issue a warning about a use of an undefined type.
2704 // The type declaration.
2705 Named_object
* named_object_
;
2706 // Whether we have issued a warning about this type.
2707 mutable bool warned_
;
2710 // The Type_context struct describes what we expect for the type of an
2715 // The exact type we expect, if known. This may be NULL.
2717 // Whether an abstract type is permitted.
2718 bool may_be_abstract
;
2722 : type(NULL
), may_be_abstract(false)
2725 Type_context(Type
* a_type
, bool a_may_be_abstract
)
2726 : type(a_type
), may_be_abstract(a_may_be_abstract
)
2730 #endif // !defined(GO_TYPES_H)