OSDN Git Service

compiler: Handle recursive interfaces.
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / types.h
1 // types.h -- Go frontend types.     -*- C++ -*-
2
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
6
7 #ifndef GO_TYPES_H
8 #define GO_TYPES_H
9
10 #include "go-linemap.h"
11
12 class Gogo;
13 class Package;
14 class Traverse;
15 class Typed_identifier;
16 class Typed_identifier_list;
17 class Integer_type;
18 class Float_type;
19 class Complex_type;
20 class String_type;
21 class Function_type;
22 class Struct_field;
23 class Struct_field_list;
24 class Struct_type;
25 class Pointer_type;
26 class Array_type;
27 class Map_type;
28 class Channel_type;
29 class Interface_type;
30 class Named_type;
31 class Forward_declaration_type;
32 class Method;
33 class Methods;
34 class Type_hash_identical;
35 class Type_identical;
36 class Expression;
37 class Expression_list;
38 class Call_expression;
39 class Field_reference_expression;
40 class Bound_method_expression;
41 class Bindings;
42 class Named_object;
43 class Function;
44 class Translate_context;
45 class Export;
46 class Import;
47 class Btype;
48 class Bexpression;
49 class Bvariable;
50
51 // Type codes used in type descriptors.  These must match the values
52 // in libgo/runtime/go-type.h.  They also match the values in the gc
53 // compiler in src/cmd/gc/reflect.c and src/pkg/runtime/type.go,
54 // although this is not required.
55
56 static const int RUNTIME_TYPE_KIND_BOOL = 1;
57 static const int RUNTIME_TYPE_KIND_INT = 2;
58 static const int RUNTIME_TYPE_KIND_INT8 = 3;
59 static const int RUNTIME_TYPE_KIND_INT16 = 4;
60 static const int RUNTIME_TYPE_KIND_INT32 = 5;
61 static const int RUNTIME_TYPE_KIND_INT64 = 6;
62 static const int RUNTIME_TYPE_KIND_UINT = 7;
63 static const int RUNTIME_TYPE_KIND_UINT8 = 8;
64 static const int RUNTIME_TYPE_KIND_UINT16 = 9;
65 static const int RUNTIME_TYPE_KIND_UINT32 = 10;
66 static const int RUNTIME_TYPE_KIND_UINT64 = 11;
67 static const int RUNTIME_TYPE_KIND_UINTPTR = 12;
68 static const int RUNTIME_TYPE_KIND_FLOAT32 = 13;
69 static const int RUNTIME_TYPE_KIND_FLOAT64 = 14;
70 static const int RUNTIME_TYPE_KIND_COMPLEX64 = 15;
71 static const int RUNTIME_TYPE_KIND_COMPLEX128 = 16;
72 static const int RUNTIME_TYPE_KIND_ARRAY = 17;
73 static const int RUNTIME_TYPE_KIND_CHAN = 18;
74 static const int RUNTIME_TYPE_KIND_FUNC = 19;
75 static const int RUNTIME_TYPE_KIND_INTERFACE = 20;
76 static const int RUNTIME_TYPE_KIND_MAP = 21;
77 static const int RUNTIME_TYPE_KIND_PTR = 22;
78 static const int RUNTIME_TYPE_KIND_SLICE = 23;
79 static const int RUNTIME_TYPE_KIND_STRING = 24;
80 static const int RUNTIME_TYPE_KIND_STRUCT = 25;
81 static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER = 26;
82
83 static const int RUNTIME_TYPE_KIND_NO_POINTERS = (1 << 7);
84
85 // To build the complete list of methods for a named type we need to
86 // gather all methods from anonymous fields.  Those methods may
87 // require an arbitrary set of indirections and field offsets.  There
88 // is also the possibility of ambiguous methods, which we could ignore
89 // except that we want to give a better error message for that case.
90 // This is a base class.  There are two types of methods: named
91 // methods, and methods which are inherited from an anonymous field of
92 // interface type.
93
94 class Method
95 {
96  public:
97   // For methods in anonymous types we need to know the sequence of
98   // field references used to extract the pointer to pass to the
99   // method.  Since each method for a particular anonymous field will
100   // have the sequence of field indexes, and since the indexes can be
101   // shared going down the chain, we use a manually managed linked
102   // list.  The first entry in the list is the field index for the
103   // last field, the one passed to the method.
104
105   struct Field_indexes
106   {
107     const Field_indexes* next;
108     unsigned int field_index;
109   };
110
111   virtual ~Method()
112   { }
113
114   // Get the list of field indexes.
115   const Field_indexes*
116   field_indexes() const
117   { return this->field_indexes_; }
118
119   // Get the depth.
120   unsigned int
121   depth() const
122   { return this->depth_; }
123
124   // Return whether this is a value method--a method which does not
125   // require a pointer expression.
126   bool
127   is_value_method() const
128   { return this->is_value_method_; }
129
130   // Return whether we need a stub method--this is true if we can't
131   // just pass the main object to the method.
132   bool
133   needs_stub_method() const
134   { return this->needs_stub_method_; }
135
136   // Return whether this is an ambiguous method name.
137   bool
138   is_ambiguous() const
139   { return this->is_ambiguous_; }
140
141   // Note that this method is ambiguous.
142   void
143   set_is_ambiguous()
144   { this->is_ambiguous_ = true; }
145
146   // Return the type of the method.
147   Function_type*
148   type() const
149   { return this->do_type(); }
150
151   // Return the location of the method receiver.
152   Location
153   receiver_location() const
154   { return this->do_receiver_location(); }
155
156   // Return an expression which binds this method to EXPR.  This is
157   // something which can be used with a function call.
158   Expression*
159   bind_method(Expression* expr, Location location) const;
160
161   // Return the named object for this method.  This may only be called
162   // after methods are finalized.
163   Named_object*
164   named_object() const;
165
166   // Get the stub object.
167   Named_object*
168   stub_object() const
169   {
170     go_assert(this->stub_ != NULL);
171     return this->stub_;
172   }
173
174   // Set the stub object.
175   void
176   set_stub_object(Named_object* no)
177   {
178     go_assert(this->stub_ == NULL);
179     this->stub_ = no;
180   }
181
182  protected:
183   // These objects are only built by the child classes.
184   Method(const Field_indexes* field_indexes, unsigned int depth,
185          bool is_value_method, bool needs_stub_method)
186     : field_indexes_(field_indexes), depth_(depth), stub_(NULL),
187       is_value_method_(is_value_method), needs_stub_method_(needs_stub_method),
188       is_ambiguous_(false)
189   { }
190
191   // The named object for this method.
192   virtual Named_object*
193   do_named_object() const = 0;
194
195   // The type of the method.
196   virtual Function_type*
197   do_type() const = 0;
198
199   // Return the location of the method receiver.
200   virtual Location
201   do_receiver_location() const = 0;
202
203   // Bind a method to an object.
204   virtual Expression*
205   do_bind_method(Expression* expr, Location location) const = 0;
206
207  private:
208   // The sequence of field indexes used for this method.  If this is
209   // NULL, then the method is defined for the current type.
210   const Field_indexes* field_indexes_;
211   // The depth at which this method was found.
212   unsigned int depth_;
213   // If a stub method is required, this is its object.  This is only
214   // set after stub methods are built in finalize_methods.
215   Named_object* stub_;
216   // Whether this is a value method--a method that does not require a
217   // pointer.
218   bool is_value_method_;
219   // Whether a stub method is required.
220   bool needs_stub_method_;
221   // Whether this method is ambiguous.
222   bool is_ambiguous_;
223 };
224
225 // A named method.  This is what you get with a method declaration,
226 // either directly on the type, or inherited from some anonymous
227 // embedded field.
228
229 class Named_method : public Method
230 {
231  public:
232   Named_method(Named_object* named_object, const Field_indexes* field_indexes,
233                unsigned int depth, bool is_value_method,
234                bool needs_stub_method)
235     : Method(field_indexes, depth, is_value_method, needs_stub_method),
236       named_object_(named_object)
237   { }
238
239  protected:
240   // Get the Named_object for the method.
241   Named_object*
242   do_named_object() const
243   { return this->named_object_; }
244
245   // The type of the method.
246   Function_type*
247   do_type() const;
248
249   // Return the location of the method receiver.
250   Location
251   do_receiver_location() const;
252
253   // Bind a method to an object.
254   Expression*
255   do_bind_method(Expression* expr, Location location) const;
256
257  private:
258   // The method itself.  For a method which needs a stub, this starts
259   // out as the underlying method, and is later replaced with the stub
260   // method.
261   Named_object* named_object_;
262 };
263
264 // An interface method.  This is used when an interface appears as an
265 // anonymous field in a named struct.
266
267 class Interface_method : public Method
268 {
269  public:
270   Interface_method(const std::string& name, Location location,
271                    Function_type* fntype, const Field_indexes* field_indexes,
272                    unsigned int depth)
273     : Method(field_indexes, depth, true, true),
274       name_(name), location_(location), fntype_(fntype)
275   { }
276
277  protected:
278   // Get the Named_object for the method.  This should never be
279   // called, as we always create a stub.
280   Named_object*
281   do_named_object() const
282   { go_unreachable(); }
283
284   // The type of the method.
285   Function_type*
286   do_type() const
287   { return this->fntype_; }
288
289   // Return the location of the method receiver.
290   Location
291   do_receiver_location() const
292   { return this->location_; }
293
294   // Bind a method to an object.
295   Expression*
296   do_bind_method(Expression* expr, Location location) const;
297
298  private:
299   // The name of the interface method to call.
300   std::string name_;
301   // The location of the definition of the interface method.
302   Location location_;
303   // The type of the interface method.
304   Function_type* fntype_;
305 };
306
307 // A mapping from method name to Method.  This is a wrapper around a
308 // hash table.
309
310 class Methods
311 {
312  private:
313   typedef Unordered_map(std::string, Method*) Method_map;
314
315  public:
316   typedef Method_map::const_iterator const_iterator;
317
318   Methods()
319     : methods_()
320   { }
321
322   // Insert a new method.  Returns true if it was inserted, false if
323   // it was overidden or ambiguous.
324   bool
325   insert(const std::string& name, Method* m);
326
327   // The number of (unambiguous) methods.
328   size_t
329   count() const;
330
331   // Iterate.
332   const_iterator
333   begin() const
334   { return this->methods_.begin(); }
335
336   const_iterator
337   end() const
338   { return this->methods_.end(); }
339
340   // Lookup.
341   const_iterator
342   find(const std::string& name) const
343   { return this->methods_.find(name); }
344
345  private:
346   Method_map methods_;
347 };
348
349 // The base class for all types.
350
351 class Type
352 {
353  public:
354   // The types of types.
355   enum Type_classification
356   {
357     TYPE_ERROR,
358     TYPE_VOID,
359     TYPE_BOOLEAN,
360     TYPE_INTEGER,
361     TYPE_FLOAT,
362     TYPE_COMPLEX,
363     TYPE_STRING,
364     TYPE_SINK,
365     TYPE_FUNCTION,
366     TYPE_POINTER,
367     TYPE_NIL,
368     TYPE_CALL_MULTIPLE_RESULT,
369     TYPE_STRUCT,
370     TYPE_ARRAY,
371     TYPE_MAP,
372     TYPE_CHANNEL,
373     TYPE_INTERFACE,
374     TYPE_NAMED,
375     TYPE_FORWARD
376   };
377
378   virtual ~Type();
379
380   // Creators.
381
382   static Type*
383   make_error_type();
384
385   static Type*
386   make_void_type();
387
388   // Get the unnamed bool type.
389   static Type*
390   make_boolean_type();
391
392   // Get the named type "bool".
393   static Named_type*
394   lookup_bool_type();
395
396   // Make the named type "bool".
397   static Named_type*
398   make_named_bool_type();
399
400   // Make an abstract integer type.
401   static Integer_type*
402   make_abstract_integer_type();
403
404   // Make a named integer type with a specified size.
405   // RUNTIME_TYPE_KIND is the code to use in reflection information,
406   // to distinguish int and int32.
407   static Named_type*
408   make_integer_type(const char* name, bool is_unsigned, int bits,
409                     int runtime_type_kind);
410
411   // Look up a named integer type.
412   static Named_type*
413   lookup_integer_type(const char* name);
414
415   // Make an abstract floating point type.
416   static Float_type*
417   make_abstract_float_type();
418
419   // Make a named floating point type with a specific size.
420   // RUNTIME_TYPE_KIND is the code to use in reflection information,
421   // to distinguish float and float32.
422   static Named_type*
423   make_float_type(const char* name, int bits, int runtime_type_kind);
424
425   // Look up a named float type.
426   static Named_type*
427   lookup_float_type(const char* name);
428
429   // Make an abstract complex type.
430   static Complex_type*
431   make_abstract_complex_type();
432
433   // Make a named complex type with a specific size.
434   // RUNTIME_TYPE_KIND is the code to use in reflection information,
435   // to distinguish complex and complex64.
436   static Named_type*
437   make_complex_type(const char* name, int bits, int runtime_type_kind);
438
439   // Look up a named complex type.
440   static Named_type*
441   lookup_complex_type(const char* name);
442
443   // Get the unnamed string type.
444   static Type*
445   make_string_type();
446
447   // Get the named type "string".
448   static Named_type*
449   lookup_string_type();
450
451   // Make the named type "string".
452   static Named_type*
453   make_named_string_type();
454
455   static Type*
456   make_sink_type();
457
458   static Function_type*
459   make_function_type(Typed_identifier* receiver,
460                      Typed_identifier_list* parameters,
461                      Typed_identifier_list* results,
462                      Location);
463
464   static Pointer_type*
465   make_pointer_type(Type*);
466
467   static Type*
468   make_nil_type();
469
470   static Type*
471   make_call_multiple_result_type(Call_expression*);
472
473   static Struct_type*
474   make_struct_type(Struct_field_list* fields, Location);
475
476   static Array_type*
477   make_array_type(Type* element_type, Expression* length);
478
479   static Map_type*
480   make_map_type(Type* key_type, Type* value_type, Location);
481
482   static Channel_type*
483   make_channel_type(bool send, bool receive, Type*);
484
485   static Interface_type*
486   make_interface_type(Typed_identifier_list* methods, Location);
487
488   static Interface_type*
489   make_empty_interface_type(Location);
490
491   static Type*
492   make_type_descriptor_type();
493
494   static Type*
495   make_type_descriptor_ptr_type();
496
497   static Named_type*
498   make_named_type(Named_object*, Type*, Location);
499
500   static Type*
501   make_forward_declaration(Named_object*);
502
503   // Traverse a type.
504   static int
505   traverse(Type*, Traverse*);
506
507   // Verify the type.  This is called after parsing, and verifies that
508   // types are complete and meet the language requirements.  This
509   // returns false if the type is invalid.
510   bool
511   verify()
512   { return this->do_verify(); }
513
514   // Return true if two types are identical.  If ERRORS_ARE_IDENTICAL,
515   // returns that an erroneous type is identical to any other type;
516   // this is used to avoid cascading errors.  If this returns false,
517   // and REASON is not NULL, it may set *REASON.
518   static bool
519   are_identical(const Type* lhs, const Type* rhs, bool errors_are_identical,
520                 std::string* reason);
521
522   // Return true if two types are compatible for use in a binary
523   // operation, other than a shift, comparison, or channel send.  This
524   // is an equivalence relation.
525   static bool
526   are_compatible_for_binop(const Type* t1, const Type* t2);
527
528   // Return true if two types are compatible for use with the
529   // comparison operator.  IS_EQUALITY_OP is true if this is an
530   // equality comparison, false if it is an ordered comparison.  This
531   // is an equivalence relation.  If this returns false, and REASON is
532   // not NULL, it sets *REASON.
533   static bool
534   are_compatible_for_comparison(bool is_equality_op, const Type *t1,
535                                 const Type *t2, std::string* reason);
536
537   // Return true if a type is comparable with itself.  This is true of
538   // most types, but false for, e.g., function types.
539   bool
540   is_comparable() const
541   { return Type::are_compatible_for_comparison(true, this, this, NULL); }
542
543   // Return true if a value with type RHS is assignable to a variable
544   // with type LHS.  This is not an equivalence relation.  If this
545   // returns false, and REASON is not NULL, it sets *REASON.
546   static bool
547   are_assignable(const Type* lhs, const Type* rhs, std::string* reason);
548
549   // Return true if a value with type RHS is assignable to a variable
550   // with type LHS, ignoring any assignment of hidden fields
551   // (unexported fields of a type imported from another package).
552   // This is like the are_assignable method.
553   static bool
554   are_assignable_hidden_ok(const Type* lhs, const Type* rhs,
555                            std::string* reason);
556
557   // Return true if a value with type RHS may be converted to type
558   // LHS.  If this returns false, and REASON is not NULL, it sets
559   // *REASON.
560   static bool
561   are_convertible(const Type* lhs, const Type* rhs, std::string* reason);
562
563   // Whether this type has any hidden fields which are not visible in
564   // the current compilation, such as a field whose name begins with a
565   // lower case letter in a struct imported from a different package.
566   // WITHIN is not NULL if we are looking at fields in a named type.
567   bool
568   has_hidden_fields(const Named_type* within, std::string* reason) const;
569
570   // Return true if values of this type can be compared using an
571   // identity function which gets nothing but a pointer to the value
572   // and a size.
573   bool
574   compare_is_identity(Gogo* gogo) const
575   { return this->do_compare_is_identity(gogo); }
576
577   // Return a hash code for this type for the method hash table.
578   // Types which are equivalent according to are_identical will have
579   // the same hash code.
580   unsigned int
581   hash_for_method(Gogo*) const;
582
583   // Return the type classification.
584   Type_classification
585   classification() const
586   { return this->classification_; }
587
588   // Return the base type for this type.  This looks through forward
589   // declarations and names.  Using this with a forward declaration
590   // which has not been defined will return an error type.
591   Type*
592   base();
593
594   const Type*
595   base() const;
596
597   // Return the type skipping defined forward declarations.  If this
598   // type is a forward declaration which has not been defined, it will
599   // return the Forward_declaration_type.  This differs from base() in
600   // that it will return a Named_type, and for a
601   // Forward_declaration_type which is not defined it will return that
602   // type rather than an error type.
603   Type*
604   forwarded();
605
606   const Type*
607   forwarded() const;
608
609   // Return true if this is a basic type: a type which is not composed
610   // of other types, and is not void.
611   bool
612   is_basic_type() const;
613
614   // Return true if this is an abstract type--an integer, floating
615   // point, or complex type whose size has not been determined.
616   bool
617   is_abstract() const;
618
619   // Return a non-abstract version of an abstract type.
620   Type*
621   make_non_abstract_type();
622
623   // Return true if this type is or contains a pointer.  This
624   // determines whether the garbage collector needs to look at a value
625   // of this type.
626   bool
627   has_pointer() const
628   { return this->do_has_pointer(); }
629
630   // Return true if this is the error type.  This returns false for a
631   // type which is not defined, as it is called by the parser before
632   // all types are defined.
633   bool
634   is_error_type() const;
635
636   // Return true if this is the error type or if the type is
637   // undefined.  If the type is undefined, this will give an error.
638   // This should only be called after parsing is complete.
639   bool
640   is_error() const
641   { return this->base()->is_error_type(); }
642
643   // Return true if this is a void type.
644   bool
645   is_void_type() const
646   { return this->classification_ == TYPE_VOID; }
647
648   // If this is an integer type, return the Integer_type.  Otherwise,
649   // return NULL.  This is a controlled dynamic_cast.
650   Integer_type*
651   integer_type()
652   { return this->convert<Integer_type, TYPE_INTEGER>(); }
653
654   const Integer_type*
655   integer_type() const
656   { return this->convert<const Integer_type, TYPE_INTEGER>(); }
657
658   // If this is a floating point type, return the Float_type.
659   // Otherwise, return NULL.  This is a controlled dynamic_cast.
660   Float_type*
661   float_type()
662   { return this->convert<Float_type, TYPE_FLOAT>(); }
663
664   const Float_type*
665   float_type() const
666   { return this->convert<const Float_type, TYPE_FLOAT>(); }
667
668   // If this is a complex type, return the Complex_type.  Otherwise,
669   // return NULL.
670   Complex_type*
671   complex_type()
672   { return this->convert<Complex_type, TYPE_COMPLEX>(); }
673
674   const Complex_type*
675   complex_type() const
676   { return this->convert<const Complex_type, TYPE_COMPLEX>(); }
677
678   // Return true if this is a boolean type.
679   bool
680   is_boolean_type() const
681   { return this->base()->classification_ == TYPE_BOOLEAN; }
682
683   // Return true if this is an abstract boolean type.
684   bool
685   is_abstract_boolean_type() const
686   { return this->classification_ == TYPE_BOOLEAN; }
687
688   // Return true if this is a string type.
689   bool
690   is_string_type() const
691   { return this->base()->classification_ == TYPE_STRING; }
692
693   // Return true if this is an abstract string type.
694   bool
695   is_abstract_string_type() const
696   { return this->classification_ == TYPE_STRING; }
697
698   // Return true if this is the sink type.  This is the type of the
699   // blank identifier _.
700   bool
701   is_sink_type() const
702   { return this->base()->classification_ == TYPE_SINK; }
703
704   // If this is a function type, return it.  Otherwise, return NULL.
705   Function_type*
706   function_type()
707   { return this->convert<Function_type, TYPE_FUNCTION>(); }
708
709   const Function_type*
710   function_type() const
711   { return this->convert<const Function_type, TYPE_FUNCTION>(); }
712
713   // If this is a pointer type, return the type to which it points.
714   // Otherwise, return NULL.
715   Type*
716   points_to() const;
717
718   // If this is a pointer type, return the type to which it points.
719   // Otherwise, return the type itself.
720   Type*
721   deref()
722   {
723     Type* pt = this->points_to();
724     return pt != NULL ? pt : this;
725   }
726
727   const Type*
728   deref() const
729   {
730     const Type* pt = this->points_to();
731     return pt != NULL ? pt : this;
732   }
733
734   // Return true if this is the nil type.  We don't use base() here,
735   // because this can be called during parse, and there is no way to
736   // name the nil type anyhow.
737   bool
738   is_nil_type() const
739   { return this->classification_ == TYPE_NIL; }
740
741   // Return true if this is the predeclared constant nil being used as
742   // a type.  This is what the parser produces for type switches which
743   // use "case nil".
744   bool
745   is_nil_constant_as_type() const;
746
747   // Return true if this is the return type of a function which
748   // returns multiple values.
749   bool
750   is_call_multiple_result_type() const
751   { return this->base()->classification_ == TYPE_CALL_MULTIPLE_RESULT; }
752
753   // If this is a struct type, return it.  Otherwise, return NULL.
754   Struct_type*
755   struct_type()
756   { return this->convert<Struct_type, TYPE_STRUCT>(); }
757
758   const Struct_type*
759   struct_type() const
760   { return this->convert<const Struct_type, TYPE_STRUCT>(); }
761
762   // If this is an array type, return it.  Otherwise, return NULL.
763   Array_type*
764   array_type()
765   { return this->convert<Array_type, TYPE_ARRAY>(); }
766
767   const Array_type*
768   array_type() const
769   { return this->convert<const Array_type, TYPE_ARRAY>(); }
770
771   // Return whether if this is a slice type.
772   bool
773   is_slice_type() const;
774
775   // If this is a map type, return it.  Otherwise, return NULL.
776   Map_type*
777   map_type()
778   { return this->convert<Map_type, TYPE_MAP>(); }
779
780   const Map_type*
781   map_type() const
782   { return this->convert<const Map_type, TYPE_MAP>(); }
783
784   // If this is a channel type, return it.  Otherwise, return NULL.
785   Channel_type*
786   channel_type()
787   { return this->convert<Channel_type, TYPE_CHANNEL>(); }
788
789   const Channel_type*
790   channel_type() const
791   { return this->convert<const Channel_type, TYPE_CHANNEL>(); }
792
793   // If this is an interface type, return it.  Otherwise, return NULL.
794   Interface_type*
795   interface_type()
796   { return this->convert<Interface_type, TYPE_INTERFACE>(); }
797
798   const Interface_type*
799   interface_type() const
800   { return this->convert<const Interface_type, TYPE_INTERFACE>(); }
801
802   // If this is a named type, return it.  Otherwise, return NULL.
803   Named_type*
804   named_type();
805
806   const Named_type*
807   named_type() const;
808
809   // If this is a forward declaration, return it.  Otherwise, return
810   // NULL.
811   Forward_declaration_type*
812   forward_declaration_type()
813   { return this->convert_no_base<Forward_declaration_type, TYPE_FORWARD>(); }
814
815   const Forward_declaration_type*
816   forward_declaration_type() const
817   {
818     return this->convert_no_base<const Forward_declaration_type,
819                                  TYPE_FORWARD>();
820   }
821
822   // Return true if this type is not yet defined.
823   bool
824   is_undefined() const;
825
826   // Return true if this is the unsafe.pointer type.  We currently
827   // represent that as pointer-to-void.
828   bool
829   is_unsafe_pointer_type() const
830   { return this->points_to() != NULL && this->points_to()->is_void_type(); }
831
832   // Look for field or method NAME for TYPE.  Return an expression for
833   // it, bound to EXPR.
834   static Expression*
835   bind_field_or_method(Gogo*, const Type* type, Expression* expr,
836                        const std::string& name, Location);
837
838   // Return true if NAME is an unexported field or method of TYPE.
839   static bool
840   is_unexported_field_or_method(Gogo*, const Type*, const std::string&,
841                                 std::vector<const Named_type*>*);
842
843   // Convert the builtin named types.
844   static void
845   convert_builtin_named_types(Gogo*);
846
847   // Return the backend representation of this type.
848   Btype*
849   get_backend(Gogo*);
850
851   // Build a type descriptor entry for this type.  Return a pointer to
852   // it.  The location is the location which causes us to need the
853   // entry.
854   tree
855   type_descriptor_pointer(Gogo* gogo, Location);
856
857   // Return the type reflection string for this type.
858   std::string
859   reflection(Gogo*) const;
860
861   // Return a mangled name for the type.  This is a name which can be
862   // used in assembler code.  Identical types should have the same
863   // manged name.
864   std::string
865   mangled_name(Gogo*) const;
866
867   // If the size of the type can be determined, set *PSIZE to the size
868   // in bytes and return true.  Otherwise, return false.  This queries
869   // the backend.
870   bool
871   backend_type_size(Gogo*, unsigned int* psize);
872
873   // If the alignment of the type can be determined, set *PALIGN to
874   // the alignment in bytes and return true.  Otherwise, return false.
875   bool
876   backend_type_align(Gogo*, unsigned int* palign);
877
878   // If the alignment of a struct field of this type can be
879   // determined, set *PALIGN to the alignment in bytes and return
880   // true.  Otherwise, return false.
881   bool
882   backend_type_field_align(Gogo*, unsigned int* palign);
883
884   // Whether the backend size is known.
885   bool
886   is_backend_type_size_known(Gogo*);
887
888   // Get the hash and equality functions for a type.
889   void
890   type_functions(Gogo*, Named_type* name, Function_type* hash_fntype,
891                  Function_type* equal_fntype, Named_object** hash_fn,
892                  Named_object** equal_fn);
893
894   // Write the hash and equality type functions.
895   void
896   write_specific_type_functions(Gogo*, Named_type*,
897                                 const std::string& hash_name,
898                                 Function_type* hash_fntype,
899                                 const std::string& equal_name,
900                                 Function_type* equal_fntype);
901
902   // Export the type.
903   void
904   export_type(Export* exp) const
905   { this->do_export(exp); }
906
907   // Import a type.
908   static Type*
909   import_type(Import*);
910
911  protected:
912   Type(Type_classification);
913
914   // Functions implemented by the child class.
915
916   // Traverse the subtypes.
917   virtual int
918   do_traverse(Traverse*);
919
920   // Verify the type.
921   virtual bool
922   do_verify()
923   { return true; }
924
925   virtual bool
926   do_has_pointer() const
927   { return false; }
928
929   virtual bool
930   do_compare_is_identity(Gogo*) const = 0;
931
932   virtual unsigned int
933   do_hash_for_method(Gogo*) const;
934
935   virtual Btype*
936   do_get_backend(Gogo*) = 0;
937
938   virtual Expression*
939   do_type_descriptor(Gogo*, Named_type* name) = 0;
940
941   virtual void
942   do_reflection(Gogo*, std::string*) const = 0;
943
944   virtual void
945   do_mangled_name(Gogo*, std::string*) const = 0;
946
947   virtual void
948   do_export(Export*) const;
949
950   // Return whether a method expects a pointer as the receiver.
951   static bool
952   method_expects_pointer(const Named_object*);
953
954   // Finalize the methods for a type.
955   static void
956   finalize_methods(Gogo*, const Type*, Location, Methods**);
957
958   // Return a method from a set of methods.
959   static Method*
960   method_function(const Methods*, const std::string& name,
961                   bool* is_ambiguous);
962
963   // Return a composite literal for the type descriptor entry for a
964   // type.
965   static Expression*
966   type_descriptor(Gogo*, Type*);
967
968   // Return a composite literal for the type descriptor entry for
969   // TYPE, using NAME as the name of the type.
970   static Expression*
971   named_type_descriptor(Gogo*, Type* type, Named_type* name);
972
973   // Return a composite literal for a plain type descriptor for this
974   // type with the given kind and name.
975   Expression*
976   plain_type_descriptor(Gogo*, int runtime_type_kind, Named_type* name);
977
978   // Build a composite literal for the basic type descriptor.
979   Expression*
980   type_descriptor_constructor(Gogo*, int runtime_type_kind, Named_type*,
981                               const Methods*, bool only_value_methods);
982
983   // Make a builtin struct type from a list of fields.
984   static Struct_type*
985   make_builtin_struct_type(int nfields, ...);
986
987   // Make a builtin named type.
988   static Named_type*
989   make_builtin_named_type(const char* name, Type* type);
990
991   // For the benefit of child class reflection string generation.
992   void
993   append_reflection(const Type* type, Gogo* gogo, std::string* ret) const
994   { type->do_reflection(gogo, ret); }
995
996   // For the benefit of child class mangling.
997   void
998   append_mangled_name(const Type* type, Gogo* gogo, std::string* ret) const
999   { type->do_mangled_name(gogo, ret); }
1000
1001   // Incorporate a string into a hash code.
1002   static unsigned int
1003   hash_string(const std::string&, unsigned int);
1004
1005   // Return the backend representation for the underlying type of a
1006   // named type.
1007   static Btype*
1008   get_named_base_btype(Gogo* gogo, Type* base_type)
1009   { return base_type->get_btype_without_hash(gogo); }
1010
1011  private:
1012   // Convert to the desired type classification, or return NULL.  This
1013   // is a controlled dynamic_cast.
1014   template<typename Type_class, Type_classification type_classification>
1015   Type_class*
1016   convert()
1017   {
1018     Type* base = this->base();
1019     return (base->classification_ == type_classification
1020             ? static_cast<Type_class*>(base)
1021             : NULL);
1022   }
1023
1024   template<typename Type_class, Type_classification type_classification>
1025   const Type_class*
1026   convert() const
1027   {
1028     const Type* base = this->base();
1029     return (base->classification_ == type_classification
1030             ? static_cast<Type_class*>(base)
1031             : NULL);
1032   }
1033
1034   template<typename Type_class, Type_classification type_classification>
1035   Type_class*
1036   convert_no_base()
1037   {
1038     return (this->classification_ == type_classification
1039             ? static_cast<Type_class*>(this)
1040             : NULL);
1041   }
1042
1043   template<typename Type_class, Type_classification type_classification>
1044   const Type_class*
1045   convert_no_base() const
1046   {
1047     return (this->classification_ == type_classification
1048             ? static_cast<Type_class*>(this)
1049             : NULL);
1050   }
1051
1052   // Support for are_assignable and are_assignable_hidden_ok.
1053   static bool
1054   are_assignable_check_hidden(const Type* lhs, const Type* rhs,
1055                               bool check_hidden_fields, std::string* reason);
1056
1057   // Map unnamed types to type descriptor decls.
1058   typedef Unordered_map_hash(const Type*, Bvariable*, Type_hash_identical,
1059                              Type_identical) Type_descriptor_vars;
1060
1061   static Type_descriptor_vars type_descriptor_vars;
1062
1063   // Build the type descriptor variable for this type.
1064   void
1065   make_type_descriptor_var(Gogo*);
1066
1067   // Return the name of the type descriptor variable.  If NAME is not
1068   // NULL, it is the name to use.
1069   std::string
1070   type_descriptor_var_name(Gogo*, Named_type* name);
1071
1072   // Return true if the type descriptor for this type should be
1073   // defined in some other package.  If NAME is not NULL, it is the
1074   // name of this type.  If this returns true it sets *PACKAGE to the
1075   // package where the type descriptor is defined.
1076   bool
1077   type_descriptor_defined_elsewhere(Named_type* name, const Package** package);
1078
1079   // Build the hash and equality type functions for a type which needs
1080   // specific functions.
1081   void
1082   specific_type_functions(Gogo*, Named_type*, Function_type* hash_fntype,
1083                           Function_type* equal_fntype, Named_object** hash_fn,
1084                           Named_object** equal_fn);
1085
1086   // Build a composite literal for the uncommon type information.
1087   Expression*
1088   uncommon_type_constructor(Gogo*, Type* uncommon_type,
1089                             Named_type*, const Methods*,
1090                             bool only_value_methods) const;
1091
1092   // Build a composite literal for the methods.
1093   Expression*
1094   methods_constructor(Gogo*, Type* methods_type, const Methods*,
1095                       bool only_value_methods) const;
1096
1097   // Build a composite literal for one method.
1098   Expression*
1099   method_constructor(Gogo*, Type* method_type, const std::string& name,
1100                      const Method*, bool only_value_methods) const;
1101
1102   static tree
1103   build_receive_return_type(tree type);
1104
1105   // A hash table we use to avoid infinite recursion.
1106   typedef Unordered_set_hash(const Named_type*, Type_hash_identical,
1107                              Type_identical) Types_seen;
1108
1109   // Add all methods for TYPE to the list of methods for THIS.
1110   static void
1111   add_methods_for_type(const Type* type, const Method::Field_indexes*,
1112                        unsigned int depth, bool, bool, Types_seen*,
1113                        Methods**);
1114
1115   static void
1116   add_local_methods_for_type(const Named_type* type,
1117                              const Method::Field_indexes*,
1118                              unsigned int depth, bool, bool, Methods**);
1119
1120   static void
1121   add_embedded_methods_for_type(const Type* type,
1122                                 const Method::Field_indexes*,
1123                                 unsigned int depth, bool, bool, Types_seen*,
1124                                 Methods**);
1125
1126   static void
1127   add_interface_methods_for_type(const Type* type,
1128                                  const Method::Field_indexes*,
1129                                  unsigned int depth, Methods**);
1130
1131   // Build stub methods for a type.
1132   static void
1133   build_stub_methods(Gogo*, const Type* type, const Methods* methods,
1134                      Location);
1135
1136   static void
1137   build_one_stub_method(Gogo*, Method*, const char* receiver_name,
1138                         const Typed_identifier_list*, bool is_varargs,
1139                         Location);
1140
1141   static Expression*
1142   apply_field_indexes(Expression*, const Method::Field_indexes*,
1143                       Location);
1144
1145   // Look for a field or method named NAME in TYPE.
1146   static bool
1147   find_field_or_method(const Type* type, const std::string& name,
1148                        bool receiver_can_be_pointer,
1149                        std::vector<const Named_type*>*, int* level,
1150                        bool* is_method, bool* found_pointer_method,
1151                        std::string* ambig1, std::string* ambig2);
1152
1153   // Get the backend representation for a type without looking in the
1154   // hash table for identical types.
1155   Btype*
1156   get_btype_without_hash(Gogo*);
1157
1158   // A mapping from Type to Btype*, used to ensure that the backend
1159   // representation of identical types is identical.
1160   typedef Unordered_map_hash(const Type*, Btype*, Type_hash_identical,
1161                              Type_identical) Type_btypes;
1162
1163   static Type_btypes type_btypes;
1164
1165   // A list of builtin named types.
1166   static std::vector<Named_type*> named_builtin_types;
1167
1168   // A map from types which need specific type functions to the type
1169   // functions themselves.
1170   typedef std::pair<Named_object*, Named_object*> Hash_equal_fn;
1171   typedef Unordered_map_hash(const Type*, Hash_equal_fn, Type_hash_identical,
1172                              Type_identical) Type_functions;
1173
1174   static Type_functions type_functions_table;
1175
1176   // The type classification.
1177   Type_classification classification_;
1178   // The backend representation of the type, once it has been
1179   // determined.
1180   Btype* btype_;
1181   // The type descriptor for this type.  This starts out as NULL and
1182   // is filled in as needed.
1183   Bvariable* type_descriptor_var_;
1184 };
1185
1186 // Type hash table operations.
1187
1188 class Type_hash_identical
1189 {
1190  public:
1191   unsigned int
1192   operator()(const Type* type) const
1193   { return type->hash_for_method(NULL); }
1194 };
1195
1196 class Type_identical
1197 {
1198  public:
1199   bool
1200   operator()(const Type* t1, const Type* t2) const
1201   { return Type::are_identical(t1, t2, false, NULL); }
1202 };
1203
1204 // An identifier with a type.
1205
1206 class Typed_identifier
1207 {
1208  public:
1209   Typed_identifier(const std::string& name, Type* type,
1210                    Location location)
1211     : name_(name), type_(type), location_(location)
1212   { }
1213
1214   // Get the name.
1215   const std::string&
1216   name() const
1217   { return this->name_; }
1218
1219   // Get the type.
1220   Type*
1221   type() const
1222   { return this->type_; }
1223
1224   // Return the location where the name was seen.  This is not always
1225   // meaningful.
1226   Location
1227   location() const
1228   { return this->location_; }
1229
1230   // Set the type--sometimes we see the identifier before the type.
1231   void
1232   set_type(Type* type)
1233   {
1234     go_assert(this->type_ == NULL || type->is_error_type());
1235     this->type_ = type;
1236   }
1237
1238  private:
1239   // Identifier name.
1240   std::string name_;
1241   // Type.
1242   Type* type_;
1243   // The location where the name was seen.
1244   Location location_;
1245 };
1246
1247 // A list of Typed_identifiers.
1248
1249 class Typed_identifier_list
1250 {
1251  public:
1252   Typed_identifier_list()
1253     : entries_()
1254   { }
1255
1256   // Whether the list is empty.
1257   bool
1258   empty() const
1259   { return this->entries_.empty(); }
1260
1261   // Return the number of entries in the list.
1262   size_t
1263   size() const
1264   { return this->entries_.size(); }
1265
1266   // Add an entry to the end of the list.
1267   void
1268   push_back(const Typed_identifier& td)
1269   { this->entries_.push_back(td); }
1270
1271   // Remove an entry from the end of the list.
1272   void
1273   pop_back()
1274   { this->entries_.pop_back(); }
1275
1276   // Set the type of entry I to TYPE.
1277   void
1278   set_type(size_t i, Type* type)
1279   {
1280     go_assert(i < this->entries_.size());
1281     this->entries_[i].set_type(type);
1282   }
1283
1284   // Sort the entries by name.
1285   void
1286   sort_by_name();
1287
1288   // Traverse types.
1289   int
1290   traverse(Traverse*);
1291
1292   // Return the first and last elements.
1293   Typed_identifier&
1294   front()
1295   { return this->entries_.front(); }
1296
1297   const Typed_identifier&
1298   front() const
1299   { return this->entries_.front(); }
1300
1301   Typed_identifier&
1302   back()
1303   { return this->entries_.back(); }
1304
1305   const Typed_identifier&
1306   back() const
1307   { return this->entries_.back(); }
1308
1309   const Typed_identifier&
1310   at(size_t i) const
1311   { return this->entries_.at(i); }
1312
1313   void
1314   set(size_t i, const Typed_identifier& t)
1315   { this->entries_.at(i) = t; }
1316
1317   void
1318   resize(size_t c)
1319   {
1320     go_assert(c <= this->entries_.size());
1321     this->entries_.resize(c, Typed_identifier("", NULL,
1322                                               Linemap::unknown_location()));
1323   }
1324
1325   void
1326   reserve(size_t c)
1327   { this->entries_.reserve(c); }
1328
1329   // Iterators.
1330
1331   typedef std::vector<Typed_identifier>::iterator iterator;
1332   typedef std::vector<Typed_identifier>::const_iterator const_iterator;
1333
1334   iterator
1335   begin()
1336   { return this->entries_.begin(); }
1337
1338   const_iterator
1339   begin() const
1340   { return this->entries_.begin(); }
1341
1342   iterator
1343   end()
1344   { return this->entries_.end(); }
1345
1346   const_iterator
1347   end() const
1348   { return this->entries_.end(); }
1349
1350   // Return a copy of this list.  This returns an independent copy of
1351   // the vector, but does not copy the types.
1352   Typed_identifier_list*
1353   copy() const;
1354
1355  private:
1356   std::vector<Typed_identifier> entries_;
1357 };
1358
1359 // The type of an integer.
1360
1361 class Integer_type : public Type
1362 {
1363  public:
1364   // Create a new integer type.
1365   static Named_type*
1366   create_integer_type(const char* name, bool is_unsigned, int bits,
1367                       int runtime_type_kind);
1368
1369   // Look up an existing integer type.
1370   static Named_type*
1371   lookup_integer_type(const char* name);
1372
1373   // Create an abstract integer type.
1374   static Integer_type*
1375   create_abstract_integer_type();
1376
1377   // Whether this is an abstract integer type.
1378   bool
1379   is_abstract() const
1380   { return this->is_abstract_; }
1381
1382   // Whether this is an unsigned type.
1383   bool
1384   is_unsigned() const
1385   { return this->is_unsigned_; }
1386
1387   // The number of bits.
1388   int
1389   bits() const
1390   { return this->bits_; }
1391
1392   // Whether this type is the same as T.
1393   bool
1394   is_identical(const Integer_type* t) const;
1395
1396   // Whether this is the type "byte" or another name for "byte".
1397   bool
1398   is_byte() const
1399   { return this->is_byte_; }
1400
1401   // Mark this as the "byte" type.
1402   void
1403   set_is_byte()
1404   { this->is_byte_ = true; }
1405
1406   // Whether this is the type "rune" or another name for "rune".
1407   bool
1408   is_rune() const
1409   { return this->is_rune_; }
1410
1411   // Mark this as the "rune" type.
1412   void
1413   set_is_rune()
1414   { this->is_rune_ = true; }
1415
1416 protected:
1417   bool
1418   do_compare_is_identity(Gogo*) const
1419   { return true; }
1420
1421   unsigned int
1422   do_hash_for_method(Gogo*) const;
1423
1424   Btype*
1425   do_get_backend(Gogo*);
1426
1427   Expression*
1428   do_type_descriptor(Gogo*, Named_type*);
1429
1430   void
1431   do_reflection(Gogo*, std::string*) const;
1432
1433   void
1434   do_mangled_name(Gogo*, std::string*) const;
1435
1436  private:
1437   Integer_type(bool is_abstract, bool is_unsigned, int bits,
1438                int runtime_type_kind)
1439     : Type(TYPE_INTEGER),
1440       is_abstract_(is_abstract), is_unsigned_(is_unsigned), is_byte_(false),
1441       is_rune_(false), bits_(bits), runtime_type_kind_(runtime_type_kind)
1442   { }
1443
1444   // Map names of integer types to the types themselves.
1445   typedef std::map<std::string, Named_type*> Named_integer_types;
1446   static Named_integer_types named_integer_types;
1447
1448   // True if this is an abstract type.
1449   bool is_abstract_;
1450   // True if this is an unsigned type.
1451   bool is_unsigned_;
1452   // True if this is the byte type.
1453   bool is_byte_;
1454   // True if this is the rune type.
1455   bool is_rune_;
1456   // The number of bits.
1457   int bits_;
1458   // The runtime type code used in the type descriptor for this type.
1459   int runtime_type_kind_;
1460 };
1461
1462 // The type of a floating point number.
1463
1464 class Float_type : public Type
1465 {
1466  public:
1467   // Create a new float type.
1468   static Named_type*
1469   create_float_type(const char* name, int bits, int runtime_type_kind);
1470
1471   // Look up an existing float type.
1472   static Named_type*
1473   lookup_float_type(const char* name);
1474
1475   // Create an abstract float type.
1476   static Float_type*
1477   create_abstract_float_type();
1478
1479   // Whether this is an abstract float type.
1480   bool
1481   is_abstract() const
1482   { return this->is_abstract_; }
1483
1484   // The number of bits.
1485   int
1486   bits() const
1487   { return this->bits_; }
1488
1489   // Whether this type is the same as T.
1490   bool
1491   is_identical(const Float_type* t) const;
1492
1493  protected:
1494   bool
1495   do_compare_is_identity(Gogo*) const
1496   { return false; }
1497
1498   unsigned int
1499   do_hash_for_method(Gogo*) const;
1500
1501   Btype*
1502   do_get_backend(Gogo*);
1503
1504   Expression*
1505   do_type_descriptor(Gogo*, Named_type*);
1506
1507   void
1508   do_reflection(Gogo*, std::string*) const;
1509
1510   void
1511   do_mangled_name(Gogo*, std::string*) const;
1512
1513  private:
1514   Float_type(bool is_abstract, int bits, int runtime_type_kind)
1515     : Type(TYPE_FLOAT),
1516       is_abstract_(is_abstract), bits_(bits),
1517       runtime_type_kind_(runtime_type_kind)
1518   { }
1519
1520   // Map names of float types to the types themselves.
1521   typedef std::map<std::string, Named_type*> Named_float_types;
1522   static Named_float_types named_float_types;
1523
1524   // True if this is an abstract type.
1525   bool is_abstract_;
1526   // The number of bits in the floating point value.
1527   int bits_;
1528   // The runtime type code used in the type descriptor for this type.
1529   int runtime_type_kind_;
1530 };
1531
1532 // The type of a complex number.
1533
1534 class Complex_type : public Type
1535 {
1536  public:
1537   // Create a new complex type.
1538   static Named_type*
1539   create_complex_type(const char* name, int bits, int runtime_type_kind);
1540
1541   // Look up an existing complex type.
1542   static Named_type*
1543   lookup_complex_type(const char* name);
1544
1545   // Create an abstract complex type.
1546   static Complex_type*
1547   create_abstract_complex_type();
1548
1549   // Whether this is an abstract complex type.
1550   bool
1551   is_abstract() const
1552   { return this->is_abstract_; }
1553
1554   // The number of bits: 64 or 128.
1555   int bits() const
1556   { return this->bits_; }
1557
1558   // Whether this type is the same as T.
1559   bool
1560   is_identical(const Complex_type* t) const;
1561
1562  protected:
1563   bool
1564   do_compare_is_identity(Gogo*) const
1565   { return false; }
1566
1567   unsigned int
1568   do_hash_for_method(Gogo*) const;
1569
1570   Btype*
1571   do_get_backend(Gogo*);
1572
1573   Expression*
1574   do_type_descriptor(Gogo*, Named_type*);
1575
1576   void
1577   do_reflection(Gogo*, std::string*) const;
1578
1579   void
1580   do_mangled_name(Gogo*, std::string*) const;
1581
1582  private:
1583   Complex_type(bool is_abstract, int bits, int runtime_type_kind)
1584     : Type(TYPE_COMPLEX),
1585       is_abstract_(is_abstract), bits_(bits),
1586       runtime_type_kind_(runtime_type_kind)
1587   { }
1588
1589   // Map names of complex types to the types themselves.
1590   typedef std::map<std::string, Named_type*> Named_complex_types;
1591   static Named_complex_types named_complex_types;
1592
1593   // True if this is an abstract type.
1594   bool is_abstract_;
1595   // The number of bits in the complex value--64 or 128.
1596   int bits_;
1597   // The runtime type code used in the type descriptor for this type.
1598   int runtime_type_kind_;
1599 };
1600
1601 // The type of a string.
1602
1603 class String_type : public Type
1604 {
1605  public:
1606   String_type()
1607     : Type(TYPE_STRING)
1608   { }
1609
1610   // Return a tree for the length of STRING.
1611   static tree
1612   length_tree(Gogo*, tree string);
1613
1614   // Return a tree which points to the bytes of STRING.
1615   static tree
1616   bytes_tree(Gogo*, tree string);
1617
1618  protected:
1619   bool
1620   do_has_pointer() const
1621   { return true; }
1622
1623   bool
1624   do_compare_is_identity(Gogo*) const
1625   { return false; }
1626
1627   Btype*
1628   do_get_backend(Gogo*);
1629
1630   Expression*
1631   do_type_descriptor(Gogo*, Named_type*);
1632
1633   void
1634   do_reflection(Gogo*, std::string*) const;
1635
1636   void
1637   do_mangled_name(Gogo*, std::string* ret) const;
1638
1639  private:
1640   // The named string type.
1641   static Named_type* string_type_;
1642 };
1643
1644 // The type of a function.
1645
1646 class Function_type : public Type
1647 {
1648  public:
1649   Function_type(Typed_identifier* receiver, Typed_identifier_list* parameters,
1650                 Typed_identifier_list* results, Location location)
1651     : Type(TYPE_FUNCTION),
1652       receiver_(receiver), parameters_(parameters), results_(results),
1653       location_(location), is_varargs_(false), is_builtin_(false)
1654   { }
1655
1656   // Get the receiver.
1657   const Typed_identifier*
1658   receiver() const
1659   { return this->receiver_; }
1660
1661   // Get the return names and types.
1662   const Typed_identifier_list*
1663   results() const
1664   { return this->results_; }
1665
1666   // Get the parameter names and types.
1667   const Typed_identifier_list*
1668   parameters() const
1669   { return this->parameters_; }
1670
1671   // Whether this is a varargs function.
1672   bool
1673   is_varargs() const
1674   { return this->is_varargs_; }
1675
1676   // Whether this is a builtin function.
1677   bool
1678   is_builtin() const
1679   { return this->is_builtin_; }
1680
1681   // The location where this type was defined.
1682   Location
1683   location() const
1684   { return this->location_; }
1685
1686   // Return whether this is a method type.
1687   bool
1688   is_method() const
1689   { return this->receiver_ != NULL; }
1690
1691   // Whether T is a valid redeclaration of this type.  This is called
1692   // when a function is declared more than once.
1693   bool
1694   is_valid_redeclaration(const Function_type* t, std::string*) const;
1695
1696   // Whether this type is the same as T.
1697   bool
1698   is_identical(const Function_type* t, bool ignore_receiver,
1699                bool errors_are_identical, std::string*) const;
1700
1701   // Record that this is a varargs function.
1702   void
1703   set_is_varargs()
1704   { this->is_varargs_ = true; }
1705
1706   // Record that this is a builtin function.
1707   void
1708   set_is_builtin()
1709   { this->is_builtin_ = true; }
1710
1711   // Import a function type.
1712   static Function_type*
1713   do_import(Import*);
1714
1715   // Return a copy of this type without a receiver.  This is only
1716   // valid for a method type.
1717   Function_type*
1718   copy_without_receiver() const;
1719
1720   // Return a copy of this type with a receiver.  This is used when an
1721   // interface method is attached to a named or struct type.
1722   Function_type*
1723   copy_with_receiver(Type*) const;
1724
1725   // Finishing converting function types.
1726   static void
1727   convert_types(Gogo*);
1728
1729   static Type*
1730   make_function_type_descriptor_type();
1731
1732  protected:
1733   int
1734   do_traverse(Traverse*);
1735
1736   // A trampoline function has a pointer which matters for GC.
1737   bool
1738   do_has_pointer() const
1739   { return true; }
1740
1741   bool
1742   do_compare_is_identity(Gogo*) const
1743   { return false; }
1744
1745   unsigned int
1746   do_hash_for_method(Gogo*) const;
1747
1748   Btype*
1749   do_get_backend(Gogo*);
1750
1751   Expression*
1752   do_type_descriptor(Gogo*, Named_type*);
1753
1754   void
1755   do_reflection(Gogo*, std::string*) const;
1756
1757   void
1758   do_mangled_name(Gogo*, std::string*) const;
1759
1760   void
1761   do_export(Export*) const;
1762
1763  private:
1764   Expression*
1765   type_descriptor_params(Type*, const Typed_identifier*,
1766                          const Typed_identifier_list*);
1767
1768   Btype*
1769   get_function_backend(Gogo*);
1770
1771   // A list of function types with multiple results and their
1772   // placeholder backend representations, used to postpone building
1773   // the structs we use for multiple results until all types are
1774   // converted.
1775   typedef std::vector<std::pair<Function_type*, Btype*> > Placeholders;
1776   static Placeholders placeholders;
1777
1778   // The receiver name and type.  This will be NULL for a normal
1779   // function, non-NULL for a method.
1780   Typed_identifier* receiver_;
1781   // The parameter names and types.
1782   Typed_identifier_list* parameters_;
1783   // The result names and types.  This will be NULL if no result was
1784   // specified.
1785   Typed_identifier_list* results_;
1786   // The location where this type was defined.  This exists solely to
1787   // give a location for the fields of the struct if this function
1788   // returns multiple values.
1789   Location location_;
1790   // Whether this function takes a variable number of arguments.
1791   bool is_varargs_;
1792   // Whether this is a special builtin function which can not simply
1793   // be called.  This is used for len, cap, etc.
1794   bool is_builtin_;
1795 };
1796
1797 // The type of a pointer.
1798
1799 class Pointer_type : public Type
1800 {
1801  public:
1802   Pointer_type(Type* to_type)
1803     : Type(TYPE_POINTER),
1804       to_type_(to_type)
1805   {}
1806
1807   Type*
1808   points_to() const
1809   { return this->to_type_; }
1810
1811   // Import a pointer type.
1812   static Pointer_type*
1813   do_import(Import*);
1814
1815   static Type*
1816   make_pointer_type_descriptor_type();
1817
1818  protected:
1819   int
1820   do_traverse(Traverse*);
1821
1822   bool
1823   do_has_pointer() const
1824   { return true; }
1825
1826   bool
1827   do_compare_is_identity(Gogo*) const
1828   { return true; }
1829
1830   unsigned int
1831   do_hash_for_method(Gogo*) const;
1832
1833   Btype*
1834   do_get_backend(Gogo*);
1835
1836   Expression*
1837   do_type_descriptor(Gogo*, Named_type*);
1838
1839   void
1840   do_reflection(Gogo*, std::string*) const;
1841
1842   void
1843   do_mangled_name(Gogo*, std::string*) const;
1844
1845   void
1846   do_export(Export*) const;
1847
1848  private:
1849   // The type to which this type points.
1850   Type* to_type_;
1851 };
1852
1853 // The type of a field in a struct.
1854
1855 class Struct_field
1856 {
1857  public:
1858   explicit Struct_field(const Typed_identifier& typed_identifier)
1859     : typed_identifier_(typed_identifier), tag_(NULL)
1860   { }
1861
1862   // The field name.
1863   const std::string&
1864   field_name() const;
1865
1866   // Return whether this struct field is named NAME.
1867   bool
1868   is_field_name(const std::string& name) const;
1869
1870   // The field type.
1871   Type*
1872   type() const
1873   { return this->typed_identifier_.type(); }
1874
1875   // The field location.
1876   Location
1877   location() const
1878   { return this->typed_identifier_.location(); }
1879
1880   // Whether the field has a tag.
1881   bool
1882   has_tag() const
1883   { return this->tag_ != NULL; }
1884
1885   // The tag.
1886   const std::string&
1887   tag() const
1888   {
1889     go_assert(this->tag_ != NULL);
1890     return *this->tag_;
1891   }
1892
1893   // Whether this is an anonymous field.
1894   bool
1895   is_anonymous() const
1896   { return this->typed_identifier_.name().empty(); }
1897
1898   // Set the tag.  FIXME: This is never freed.
1899   void
1900   set_tag(const std::string& tag)
1901   { this->tag_ = new std::string(tag); }
1902
1903   // Set the type.  This is only used in error cases.
1904   void
1905   set_type(Type* type)
1906   { this->typed_identifier_.set_type(type); }
1907
1908  private:
1909   // The field name, type, and location.
1910   Typed_identifier typed_identifier_;
1911   // The field tag.  This is NULL if the field has no tag.
1912   std::string* tag_;
1913 };
1914
1915 // A list of struct fields.
1916
1917 class Struct_field_list
1918 {
1919  public:
1920   Struct_field_list()
1921     : entries_()
1922   { }
1923
1924   // Whether the list is empty.
1925   bool
1926   empty() const
1927   { return this->entries_.empty(); }
1928
1929   // Return the number of entries.
1930   size_t
1931   size() const
1932   { return this->entries_.size(); }
1933
1934   // Add an entry to the end of the list.
1935   void
1936   push_back(const Struct_field& sf)
1937   { this->entries_.push_back(sf); }
1938
1939   // Index into the list.
1940   const Struct_field&
1941   at(size_t i) const
1942   { return this->entries_.at(i); }
1943
1944   // Last entry in list.
1945   Struct_field&
1946   back()
1947   { return this->entries_.back(); }
1948
1949   // Iterators.
1950
1951   typedef std::vector<Struct_field>::iterator iterator;
1952   typedef std::vector<Struct_field>::const_iterator const_iterator;
1953
1954   iterator
1955   begin()
1956   { return this->entries_.begin(); }
1957
1958   const_iterator
1959   begin() const
1960   { return this->entries_.begin(); }
1961
1962   iterator
1963   end()
1964   { return this->entries_.end(); }
1965
1966   const_iterator
1967   end() const
1968   { return this->entries_.end(); }
1969
1970  private:
1971   std::vector<Struct_field> entries_;
1972 };
1973
1974 // The type of a struct.
1975
1976 class Struct_type : public Type
1977 {
1978  public:
1979   Struct_type(Struct_field_list* fields, Location location)
1980     : Type(TYPE_STRUCT),
1981       fields_(fields), location_(location), all_methods_(NULL)
1982   { }
1983
1984   // Return the field NAME.  This only looks at local fields, not at
1985   // embedded types.  If the field is found, and PINDEX is not NULL,
1986   // this sets *PINDEX to the field index.  If the field is not found,
1987   // this returns NULL.
1988   const Struct_field*
1989   find_local_field(const std::string& name, unsigned int *pindex) const;
1990
1991   // Return the field number INDEX.
1992   const Struct_field*
1993   field(unsigned int index) const
1994   { return &this->fields_->at(index); }
1995
1996   // Get the struct fields.
1997   const Struct_field_list*
1998   fields() const
1999   { return this->fields_; }
2000
2001   // Return the number of fields.
2002   size_t
2003   field_count() const
2004   { return this->fields_->size(); }
2005
2006   // Push a new field onto the end of the struct.  This is used when
2007   // building a closure variable.
2008   void
2009   push_field(const Struct_field& sf)
2010   { this->fields_->push_back(sf); }
2011
2012   // Return an expression referring to field NAME in STRUCT_EXPR, or
2013   // NULL if there is no field with that name.
2014   Field_reference_expression*
2015   field_reference(Expression* struct_expr, const std::string& name,
2016                   Location) const;
2017
2018   // Return the total number of fields, including embedded fields.
2019   // This is the number of values that can appear in a conversion to
2020   // this type.
2021   unsigned int
2022   total_field_count() const;
2023
2024   // Whether this type is identical with T.
2025   bool
2026   is_identical(const Struct_type* t, bool errors_are_identical) const;
2027
2028   // Whether this struct type has any hidden fields.  This returns
2029   // true if any fields have hidden names, or if any non-pointer
2030   // anonymous fields have types with hidden fields.
2031   bool
2032   struct_has_hidden_fields(const Named_type* within, std::string*) const;
2033
2034   // Return whether NAME is a local field which is not exported.  This
2035   // is only used for better error reporting.
2036   bool
2037   is_unexported_local_field(Gogo*, const std::string& name) const;
2038
2039   // If this is an unnamed struct, build the complete list of methods,
2040   // including those from anonymous fields, and build methods stubs if
2041   // needed.
2042   void
2043   finalize_methods(Gogo*);
2044
2045   // Return whether this type has any methods.  This should only be
2046   // called after the finalize_methods pass.
2047   bool
2048   has_any_methods() const
2049   { return this->all_methods_ != NULL; }
2050
2051   // Return the methods for tihs type.  This should only be called
2052   // after the finalize_methods pass.
2053   const Methods*
2054   methods() const
2055   { return this->all_methods_; }
2056
2057   // Return the method to use for NAME.  This returns NULL if there is
2058   // no such method or if the method is ambiguous.  When it returns
2059   // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2060   Method*
2061   method_function(const std::string& name, bool* is_ambiguous) const;
2062
2063   // Traverse just the field types of a struct type.
2064   int
2065   traverse_field_types(Traverse* traverse)
2066   { return this->do_traverse(traverse); }
2067
2068   // If the offset of field INDEX in the backend implementation can be
2069   // determined, set *POFFSET to the offset in bytes and return true.
2070   // Otherwise, return false.
2071   bool
2072   backend_field_offset(Gogo*, unsigned int index, unsigned int* poffset);
2073
2074   // Import a struct type.
2075   static Struct_type*
2076   do_import(Import*);
2077
2078   static Type*
2079   make_struct_type_descriptor_type();
2080
2081   // Write the hash function for this type.
2082   void
2083   write_hash_function(Gogo*, Named_type*, Function_type*, Function_type*);
2084
2085   // Write the equality function for this type.
2086   void
2087   write_equal_function(Gogo*, Named_type*);
2088
2089  protected:
2090   int
2091   do_traverse(Traverse*);
2092
2093   bool
2094   do_verify();
2095
2096   bool
2097   do_has_pointer() const;
2098
2099   bool
2100   do_compare_is_identity(Gogo*) const;
2101
2102   unsigned int
2103   do_hash_for_method(Gogo*) const;
2104
2105   Btype*
2106   do_get_backend(Gogo*);
2107
2108   Expression*
2109   do_type_descriptor(Gogo*, Named_type*);
2110
2111   void
2112   do_reflection(Gogo*, std::string*) const;
2113
2114   void
2115   do_mangled_name(Gogo*, std::string*) const;
2116
2117   void
2118   do_export(Export*) const;
2119
2120  private:
2121   // Used to avoid infinite loops in field_reference_depth.
2122   struct Saw_named_type
2123   {
2124     Saw_named_type* next;
2125     Named_type* nt;
2126   };
2127
2128   Field_reference_expression*
2129   field_reference_depth(Expression* struct_expr, const std::string& name,
2130                         Location, Saw_named_type*,
2131                         unsigned int* depth) const;
2132
2133   // The fields of the struct.
2134   Struct_field_list* fields_;
2135   // The place where the struct was declared.
2136   Location location_;
2137   // If this struct is unnamed, a list of methods.
2138   Methods* all_methods_;
2139 };
2140
2141 // The type of an array.
2142
2143 class Array_type : public Type
2144 {
2145  public:
2146   Array_type(Type* element_type, Expression* length)
2147     : Type(TYPE_ARRAY),
2148       element_type_(element_type), length_(length), length_tree_(NULL)
2149   { }
2150
2151   // Return the element type.
2152   Type*
2153   element_type() const
2154   { return this->element_type_; }
2155
2156   // Return the length.  This will return NULL for an open array.
2157   Expression*
2158   length() const
2159   { return this->length_; }
2160
2161   // Whether this type is identical with T.
2162   bool
2163   is_identical(const Array_type* t, bool errors_are_identical) const;
2164
2165   // Whether this type has any hidden fields.
2166   bool
2167   array_has_hidden_fields(const Named_type* within, std::string* reason) const
2168   { return this->element_type_->has_hidden_fields(within, reason); }
2169
2170   // Return a tree for the pointer to the values in an array.
2171   tree
2172   value_pointer_tree(Gogo*, tree array) const;
2173
2174   // Return a tree for the length of an array with this type.
2175   tree
2176   length_tree(Gogo*, tree array);
2177
2178   // Return a tree for the capacity of an array with this type.
2179   tree
2180   capacity_tree(Gogo*, tree array);
2181
2182   // Import an array type.
2183   static Array_type*
2184   do_import(Import*);
2185
2186   // Return the backend representation of the element type.
2187   Btype*
2188   get_backend_element(Gogo*);
2189
2190   // Return the backend representation of the length.
2191   Bexpression*
2192   get_backend_length(Gogo*);
2193
2194   static Type*
2195   make_array_type_descriptor_type();
2196
2197   static Type*
2198   make_slice_type_descriptor_type();
2199
2200   // Write the hash function for this type.
2201   void
2202   write_hash_function(Gogo*, Named_type*, Function_type*, Function_type*);
2203
2204   // Write the equality function for this type.
2205   void
2206   write_equal_function(Gogo*, Named_type*);
2207
2208  protected:
2209   int
2210   do_traverse(Traverse* traverse);
2211
2212   bool
2213   do_verify();
2214
2215   bool
2216   do_has_pointer() const
2217   {
2218     return this->length_ == NULL || this->element_type_->has_pointer();
2219   }
2220
2221   bool
2222   do_compare_is_identity(Gogo*) const;
2223
2224   unsigned int
2225   do_hash_for_method(Gogo*) const;
2226
2227   Btype*
2228   do_get_backend(Gogo*);
2229
2230   Expression*
2231   do_type_descriptor(Gogo*, Named_type*);
2232
2233   void
2234   do_reflection(Gogo*, std::string*) const;
2235
2236   void
2237   do_mangled_name(Gogo*, std::string*) const;
2238
2239   void
2240   do_export(Export*) const;
2241
2242  private:
2243   bool
2244   verify_length();
2245
2246   tree
2247   get_length_tree(Gogo*);
2248
2249   Expression*
2250   array_type_descriptor(Gogo*, Named_type*);
2251
2252   Expression*
2253   slice_type_descriptor(Gogo*, Named_type*);
2254
2255   // The type of elements of the array.
2256   Type* element_type_;
2257   // The number of elements.  This may be NULL.
2258   Expression* length_;
2259   // The length as a tree.  We only want to compute this once.
2260   tree length_tree_;
2261 };
2262
2263 // The type of a map.
2264
2265 class Map_type : public Type
2266 {
2267  public:
2268   Map_type(Type* key_type, Type* val_type, Location location)
2269     : Type(TYPE_MAP),
2270       key_type_(key_type), val_type_(val_type), location_(location)
2271   { }
2272
2273   // Return the key type.
2274   Type*
2275   key_type() const
2276   { return this->key_type_; }
2277
2278   // Return the value type.
2279   Type*
2280   val_type() const
2281   { return this->val_type_; }
2282
2283   // Whether this type is identical with T.
2284   bool
2285   is_identical(const Map_type* t, bool errors_are_identical) const;
2286
2287   // Import a map type.
2288   static Map_type*
2289   do_import(Import*);
2290
2291   static Type*
2292   make_map_type_descriptor_type();
2293
2294   static Type*
2295   make_map_descriptor_type();
2296
2297   // Build a map descriptor for this type.  Return a pointer to it.
2298   // The location is the location which causes us to need the
2299   // descriptor.
2300   tree
2301   map_descriptor_pointer(Gogo* gogo, Location);
2302
2303  protected:
2304   int
2305   do_traverse(Traverse*);
2306
2307   bool
2308   do_verify();
2309
2310   bool
2311   do_has_pointer() const
2312   { return true; }
2313
2314   bool
2315   do_compare_is_identity(Gogo*) const
2316   { return false; }
2317
2318   unsigned int
2319   do_hash_for_method(Gogo*) const;
2320
2321   Btype*
2322   do_get_backend(Gogo*);
2323
2324   Expression*
2325   do_type_descriptor(Gogo*, Named_type*);
2326
2327   void
2328   do_reflection(Gogo*, std::string*) const;
2329
2330   void
2331   do_mangled_name(Gogo*, std::string*) const;
2332
2333   void
2334   do_export(Export*) const;
2335
2336  private:
2337   // Mapping from map types to map descriptors.
2338   typedef Unordered_map_hash(const Map_type*, Bvariable*, Type_hash_identical,
2339                              Type_identical) Map_descriptors;
2340   static Map_descriptors map_descriptors;
2341
2342   Bvariable*
2343   map_descriptor(Gogo*);
2344
2345   // The key type.
2346   Type* key_type_;
2347   // The value type.
2348   Type* val_type_;
2349   // Where the type was defined.
2350   Location location_;
2351 };
2352
2353 // The type of a channel.
2354
2355 class Channel_type : public Type
2356 {
2357  public:
2358   Channel_type(bool may_send, bool may_receive, Type* element_type)
2359     : Type(TYPE_CHANNEL),
2360       may_send_(may_send), may_receive_(may_receive),
2361       element_type_(element_type)
2362   { go_assert(may_send || may_receive); }
2363
2364   // Whether this channel can send data.
2365   bool
2366   may_send() const
2367   { return this->may_send_; }
2368
2369   // Whether this channel can receive data.
2370   bool
2371   may_receive() const
2372   { return this->may_receive_; }
2373
2374   // The type of the values that may be sent on this channel.  This is
2375   // NULL if any type may be sent.
2376   Type*
2377   element_type() const
2378   { return this->element_type_; }
2379
2380   // Whether this type is identical with T.
2381   bool
2382   is_identical(const Channel_type* t, bool errors_are_identical) const;
2383
2384   // Import a channel type.
2385   static Channel_type*
2386   do_import(Import*);
2387
2388   static Type*
2389   make_chan_type_descriptor_type();
2390
2391  protected:
2392   int
2393   do_traverse(Traverse* traverse)
2394   { return Type::traverse(this->element_type_, traverse); }
2395
2396   bool
2397   do_has_pointer() const
2398   { return true; }
2399
2400   bool
2401   do_compare_is_identity(Gogo*) const
2402   { return true; }
2403
2404   unsigned int
2405   do_hash_for_method(Gogo*) const;
2406
2407   Btype*
2408   do_get_backend(Gogo*);
2409
2410   Expression*
2411   do_type_descriptor(Gogo*, Named_type*);
2412
2413   void
2414   do_reflection(Gogo*, std::string*) const;
2415
2416   void
2417   do_mangled_name(Gogo*, std::string*) const;
2418
2419   void
2420   do_export(Export*) const;
2421
2422  private:
2423   // Whether this channel can send data.
2424   bool may_send_;
2425   // Whether this channel can receive data.
2426   bool may_receive_;
2427   // The types of elements which may be sent on this channel.  If this
2428   // is NULL, it means that any type may be sent.
2429   Type* element_type_;
2430 };
2431
2432 // An interface type.
2433
2434 class Interface_type : public Type
2435 {
2436  public:
2437   Interface_type(Typed_identifier_list* methods, Location location)
2438     : Type(TYPE_INTERFACE),
2439       parse_methods_(methods), all_methods_(NULL), location_(location),
2440       interface_btype_(NULL), assume_identical_(NULL),
2441       methods_are_finalized_(false), seen_(false)
2442   { go_assert(methods == NULL || !methods->empty()); }
2443
2444   // The location where the interface type was defined.
2445   Location
2446   location() const
2447   { return this->location_; }
2448
2449   // Return whether this is an empty interface.
2450   bool
2451   is_empty() const
2452   {
2453     go_assert(this->methods_are_finalized_);
2454     return this->all_methods_ == NULL;
2455   }
2456
2457   // Return the list of methods.  This will return NULL for an empty
2458   // interface.
2459   const Typed_identifier_list*
2460   methods() const
2461   {
2462     go_assert(this->methods_are_finalized_);
2463     return this->all_methods_;
2464   }
2465
2466   // Return the number of methods.
2467   size_t
2468   method_count() const
2469   {
2470     go_assert(this->methods_are_finalized_);
2471     return this->all_methods_ == NULL ? 0 : this->all_methods_->size();
2472   }
2473
2474   // Return the method NAME, or NULL.
2475   const Typed_identifier*
2476   find_method(const std::string& name) const;
2477
2478   // Return the zero-based index of method NAME.
2479   size_t
2480   method_index(const std::string& name) const;
2481
2482   // Finalize the methods.  This sets all_methods_.  This handles
2483   // interface inheritance.
2484   void
2485   finalize_methods();
2486
2487   // Return true if T implements this interface.  If this returns
2488   // false, and REASON is not NULL, it sets *REASON to the reason that
2489   // it fails.
2490   bool
2491   implements_interface(const Type* t, std::string* reason) const;
2492
2493   // Whether this type is identical with T.  REASON is as in
2494   // implements_interface.
2495   bool
2496   is_identical(const Interface_type* t, bool errors_are_identical) const;
2497
2498   // Whether we can assign T to this type.  is_identical is known to
2499   // be false.
2500   bool
2501   is_compatible_for_assign(const Interface_type*, std::string* reason) const;
2502
2503   // Return whether NAME is a method which is not exported.  This is
2504   // only used for better error reporting.
2505   bool
2506   is_unexported_method(Gogo*, const std::string& name) const;
2507
2508   // Import an interface type.
2509   static Interface_type*
2510   do_import(Import*);
2511
2512   // Make a struct for an empty interface type.
2513   static Btype*
2514   get_backend_empty_interface_type(Gogo*);
2515
2516   static Type*
2517   make_interface_type_descriptor_type();
2518
2519  protected:
2520   int
2521   do_traverse(Traverse*);
2522
2523   bool
2524   do_has_pointer() const
2525   { return true; }
2526
2527   bool
2528   do_compare_is_identity(Gogo*) const
2529   { return false; }
2530
2531   unsigned int
2532   do_hash_for_method(Gogo*) const;
2533
2534   Btype*
2535   do_get_backend(Gogo*);
2536
2537   Expression*
2538   do_type_descriptor(Gogo*, Named_type*);
2539
2540   void
2541   do_reflection(Gogo*, std::string*) const;
2542
2543   void
2544   do_mangled_name(Gogo*, std::string*) const;
2545
2546   void
2547   do_export(Export*) const;
2548
2549  private:
2550   // This type guards against infinite recursion when comparing
2551   // interface types.  We keep a list of interface types assumed to be
2552   // identical during comparison.  We just keep the list on the stack.
2553   // This permits us to compare cases like
2554   // type I1 interface { F() interface{I1} }
2555   // type I2 interface { F() interface{I2} }
2556   struct Assume_identical
2557   {
2558     Assume_identical* next;
2559     const Interface_type* t1;
2560     const Interface_type* t2;
2561   };
2562
2563   bool
2564   assume_identical(const Interface_type*, const Interface_type*) const;
2565
2566   // The list of methods associated with the interface from the
2567   // parser.  This will be NULL for the empty interface.  This may
2568   // include unnamed interface types.
2569   Typed_identifier_list* parse_methods_;
2570   // The list of all methods associated with the interface.  This
2571   // expands any interface types listed in methods_.  It is set by
2572   // finalize_methods.  This will be NULL for the empty interface.
2573   Typed_identifier_list* all_methods_;
2574   // The location where the interface was defined.
2575   Location location_;
2576   // The backend representation of this type during backend conversion.
2577   Btype* interface_btype_;
2578   // A list of interface types assumed to be identical during
2579   // interface comparison.
2580   mutable Assume_identical* assume_identical_;
2581   // Whether the methods have been finalized.
2582   bool methods_are_finalized_;
2583   // Used to avoid endless recursion in do_mangled_name.
2584   mutable bool seen_;
2585 };
2586
2587 // The value we keep for a named type.  This lets us get the right
2588 // name when we convert to trees.  Note that we don't actually keep
2589 // the name here; the name is in the Named_object which points to
2590 // this.  This object exists to hold a unique tree which represents
2591 // the type.
2592
2593 class Named_type : public Type
2594 {
2595  public:
2596   Named_type(Named_object* named_object, Type* type, Location location)
2597     : Type(TYPE_NAMED),
2598       named_object_(named_object), in_function_(NULL), type_(type),
2599       local_methods_(NULL), all_methods_(NULL),
2600       interface_method_tables_(NULL), pointer_interface_method_tables_(NULL),
2601       location_(location), named_btype_(NULL), dependencies_(),
2602       is_visible_(true), is_error_(false), is_placeholder_(false),
2603       is_converted_(false), is_circular_(false), seen_(false),
2604       seen_in_compare_is_identity_(false), seen_in_get_backend_(false)
2605   { }
2606
2607   // Return the associated Named_object.  This holds the actual name.
2608   Named_object*
2609   named_object()
2610   { return this->named_object_; }
2611
2612   const Named_object*
2613   named_object() const
2614   { return this->named_object_; }
2615
2616   // Set the Named_object.  This is used when we see a type
2617   // declaration followed by a type.
2618   void
2619   set_named_object(Named_object* no)
2620   { this->named_object_ = no; }
2621
2622   // Return the function in which this type is defined.  This will
2623   // return NULL for a type defined in global scope.
2624   const Named_object*
2625   in_function() const
2626   { return this->in_function_; }
2627
2628   // Set the function in which this type is defined.
2629   void
2630   set_in_function(Named_object* f)
2631   { this->in_function_ = f; }
2632
2633   // Return the name of the type.
2634   const std::string&
2635   name() const;
2636
2637   // Return the name of the type for an error message.  The difference
2638   // is that if the type is defined in a different package, this will
2639   // return PACKAGE.NAME.
2640   std::string
2641   message_name() const;
2642
2643   // Return the underlying type.
2644   Type*
2645   real_type()
2646   { return this->type_; }
2647
2648   const Type*
2649   real_type() const
2650   { return this->type_; }
2651
2652   // Return the location.
2653   Location
2654   location() const
2655   { return this->location_; }
2656
2657   // Whether this type is visible.  This only matters when parsing.
2658   bool
2659   is_visible() const
2660   { return this->is_visible_; }
2661
2662   // Mark this type as visible.
2663   void
2664   set_is_visible()
2665   { this->is_visible_ = true; }
2666
2667   // Mark this type as invisible.
2668   void
2669   clear_is_visible()
2670   { this->is_visible_ = false; }
2671
2672   // Whether this is a builtin type.
2673   bool
2674   is_builtin() const
2675   { return Linemap::is_predeclared_location(this->location_); }
2676
2677   // Whether this is a circular type: a pointer or function type that
2678   // refers to itself, which is not possible in C.
2679   bool
2680   is_circular() const
2681   { return this->is_circular_; }
2682
2683   // Return the base type for this type.
2684   Type*
2685   named_base();
2686
2687   const Type*
2688   named_base() const;
2689
2690   // Return whether this is an error type.
2691   bool
2692   is_named_error_type() const;
2693
2694   // Return whether this type is comparable.  If REASON is not NULL,
2695   // set *REASON when returning false.
2696   bool
2697   named_type_is_comparable(std::string* reason) const;
2698
2699   // Add a method to this type.
2700   Named_object*
2701   add_method(const std::string& name, Function*);
2702
2703   // Add a method declaration to this type.
2704   Named_object*
2705   add_method_declaration(const std::string& name, Package* package,
2706                          Function_type* type, Location location);
2707
2708   // Add an existing method--one defined before the type itself was
2709   // defined--to a type.
2710   void
2711   add_existing_method(Named_object*);
2712
2713   // Look up a local method.
2714   Named_object*
2715   find_local_method(const std::string& name) const;
2716
2717   // Return the list of local methods.
2718   const Bindings*
2719   local_methods() const
2720   { return this->local_methods_; }
2721
2722   // Build the complete list of methods, including those from
2723   // anonymous fields, and build method stubs if needed.
2724   void
2725   finalize_methods(Gogo*);
2726
2727   // Return whether this type has any methods.  This should only be
2728   // called after the finalize_methods pass.
2729   bool
2730   has_any_methods() const
2731   { return this->all_methods_ != NULL; }
2732
2733   // Return the methods for this type.  This should only be called
2734   // after the finalized_methods pass.
2735   const Methods*
2736   methods() const
2737   { return this->all_methods_; }
2738
2739   // Return the method to use for NAME.  This returns NULL if there is
2740   // no such method or if the method is ambiguous.  When it returns
2741   // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2742   Method*
2743   method_function(const std::string& name, bool *is_ambiguous) const;
2744
2745   // Return whether NAME is a known field or method which is not
2746   // exported.  This is only used for better error reporting.
2747   bool
2748   is_unexported_local_method(Gogo*, const std::string& name) const;
2749
2750   // Return a pointer to the interface method table for this type for
2751   // the interface INTERFACE.  If IS_POINTER is true, set the type
2752   // descriptor to a pointer to this type, otherwise set it to this
2753   // type.
2754   tree
2755   interface_method_table(Gogo*, const Interface_type* interface,
2756                          bool is_pointer);
2757
2758   // Whether this type has any hidden fields.
2759   bool
2760   named_type_has_hidden_fields(std::string* reason) const;
2761
2762   // Note that a type must be converted to the backend representation
2763   // before we convert this type.
2764   void
2765   add_dependency(Named_type* nt)
2766   { this->dependencies_.push_back(nt); }
2767
2768   // Return true if the size and alignment of the backend
2769   // representation of this type is known.  This is always true after
2770   // types have been converted, but may be false beforehand.
2771   bool
2772   is_named_backend_type_size_known() const
2773   { return this->named_btype_ != NULL && !this->is_placeholder_; }
2774
2775   // Export the type.
2776   void
2777   export_named_type(Export*, const std::string& name) const;
2778
2779   // Import a named type.
2780   static void
2781   import_named_type(Import*, Named_type**);
2782
2783   // Initial conversion to backend representation.
2784   void
2785   convert(Gogo*);
2786
2787  protected:
2788   int
2789   do_traverse(Traverse* traverse)
2790   { return Type::traverse(this->type_, traverse); }
2791
2792   bool
2793   do_verify();
2794
2795   bool
2796   do_has_pointer() const;
2797
2798   bool
2799   do_compare_is_identity(Gogo*) const;
2800
2801   unsigned int
2802   do_hash_for_method(Gogo*) const;
2803
2804   Btype*
2805   do_get_backend(Gogo*);
2806
2807   Expression*
2808   do_type_descriptor(Gogo*, Named_type*);
2809
2810   void
2811   do_reflection(Gogo*, std::string*) const;
2812
2813   void
2814   do_mangled_name(Gogo*, std::string* ret) const;
2815
2816   void
2817   do_export(Export*) const;
2818
2819  private:
2820   // Create the placeholder during conversion.
2821   void
2822   create_placeholder(Gogo*);
2823
2824   // A mapping from interfaces to the associated interface method
2825   // tables for this type.  This maps to a decl.
2826   typedef Unordered_map_hash(const Interface_type*, tree, Type_hash_identical,
2827                              Type_identical) Interface_method_tables;
2828
2829   // A pointer back to the Named_object for this type.
2830   Named_object* named_object_;
2831   // If this type is defined in a function, a pointer back to the
2832   // function in which it is defined.
2833   Named_object* in_function_;
2834   // The actual type.
2835   Type* type_;
2836   // The list of methods defined for this type.  Any named type can
2837   // have methods.
2838   Bindings* local_methods_;
2839   // The full list of methods for this type, including methods
2840   // declared for anonymous fields.
2841   Methods* all_methods_;
2842   // A mapping from interfaces to the associated interface method
2843   // tables for this type.
2844   Interface_method_tables* interface_method_tables_;
2845   // A mapping from interfaces to the associated interface method
2846   // tables for pointers to this type.
2847   Interface_method_tables* pointer_interface_method_tables_;
2848   // The location where this type was defined.
2849   Location location_;
2850   // The backend representation of this type during backend
2851   // conversion.  This is used to avoid endless recursion when a named
2852   // type refers to itself.
2853   Btype* named_btype_;
2854   // A list of types which must be converted to the backend
2855   // representation before this type can be converted.  This is for
2856   // cases like
2857   //   type S1 { p *S2 }
2858   //   type S2 { s S1 }
2859   // where we can't convert S2 to the backend representation unless we
2860   // have converted S1.
2861   std::vector<Named_type*> dependencies_;
2862   // Whether this type is visible.  This is false if this type was
2863   // created because it was referenced by an imported object, but the
2864   // type itself was not exported.  This will always be true for types
2865   // created in the current package.
2866   bool is_visible_;
2867   // Whether this type is erroneous.
2868   bool is_error_;
2869   // Whether the current value of named_btype_ is a placeholder for
2870   // which the final size of the type is not known.
2871   bool is_placeholder_;
2872   // Whether this type has been converted to the backend
2873   // representation.  Implies that is_placeholder_ is false.
2874   bool is_converted_;
2875   // Whether this is a pointer or function type which refers to the
2876   // type itself.
2877   bool is_circular_;
2878   // In a recursive operation such as has_hidden_fields, this flag is
2879   // used to prevent infinite recursion when a type refers to itself.
2880   // This is mutable because it is always reset to false when the
2881   // function exits.
2882   mutable bool seen_;
2883   // Like seen_, but used only by do_compare_is_identity.
2884   mutable bool seen_in_compare_is_identity_;
2885   // Like seen_, but used only by do_get_backend.
2886   bool seen_in_get_backend_;
2887 };
2888
2889 // A forward declaration.  This handles a type which has been declared
2890 // but not defined.
2891
2892 class Forward_declaration_type : public Type
2893 {
2894  public:
2895   Forward_declaration_type(Named_object* named_object);
2896
2897   // The named object associated with this type declaration.  This
2898   // will be resolved.
2899   Named_object*
2900   named_object();
2901
2902   const Named_object*
2903   named_object() const;
2904
2905   // Return the name of the type.
2906   const std::string&
2907   name() const;
2908
2909   // Return the type to which this points.  Give an error if the type
2910   // has not yet been defined.
2911   Type*
2912   real_type();
2913
2914   const Type*
2915   real_type() const;
2916
2917   // Whether the base type has been defined.
2918   bool
2919   is_defined() const;
2920
2921   // Add a method to this type.
2922   Named_object*
2923   add_method(const std::string& name, Function*);
2924
2925   // Add a method declaration to this type.
2926   Named_object*
2927   add_method_declaration(const std::string& name, Function_type*,
2928                          Location);
2929
2930  protected:
2931   int
2932   do_traverse(Traverse* traverse);
2933
2934   bool
2935   do_has_pointer() const
2936   { return this->real_type()->has_pointer(); }
2937
2938   bool
2939   do_compare_is_identity(Gogo* gogo) const
2940   { return this->real_type()->compare_is_identity(gogo); }
2941
2942   unsigned int
2943   do_hash_for_method(Gogo* gogo) const
2944   { return this->real_type()->hash_for_method(gogo); }
2945
2946   Btype*
2947   do_get_backend(Gogo* gogo);
2948
2949   Expression*
2950   do_type_descriptor(Gogo*, Named_type*);
2951
2952   void
2953   do_reflection(Gogo*, std::string*) const;
2954
2955   void
2956   do_mangled_name(Gogo*, std::string* ret) const;
2957
2958   void
2959   do_export(Export*) const;
2960
2961  private:
2962   // Issue a warning about a use of an undefined type.
2963   void
2964   warn() const;
2965
2966   // The type declaration.
2967   Named_object* named_object_;
2968   // Whether we have issued a warning about this type.
2969   mutable bool warned_;
2970 };
2971
2972 // The Type_context struct describes what we expect for the type of an
2973 // expression.
2974
2975 struct Type_context
2976 {
2977   // The exact type we expect, if known.  This may be NULL.
2978   Type* type;
2979   // Whether an abstract type is permitted.
2980   bool may_be_abstract;
2981
2982   // Constructors.
2983   Type_context()
2984     : type(NULL), may_be_abstract(false)
2985   { }
2986
2987   Type_context(Type* a_type, bool a_may_be_abstract)
2988     : type(a_type), may_be_abstract(a_may_be_abstract)
2989   { }
2990 };
2991
2992 #endif // !defined(GO_TYPES_H)