OSDN Git Service

b00b007aa1c0d43c3c13751feba048c13ec3bf63
[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 Type*
489   make_type_descriptor_type();
490
491   static Type*
492   make_type_descriptor_ptr_type();
493
494   static Named_type*
495   make_named_type(Named_object*, Type*, Location);
496
497   static Type*
498   make_forward_declaration(Named_object*);
499
500   // Traverse a type.
501   static int
502   traverse(Type*, Traverse*);
503
504   // Verify the type.  This is called after parsing, and verifies that
505   // types are complete and meet the language requirements.  This
506   // returns false if the type is invalid.
507   bool
508   verify()
509   { return this->do_verify(); }
510
511   // Return true if two types are identical.  If ERRORS_ARE_IDENTICAL,
512   // returns that an erroneous type is identical to any other type;
513   // this is used to avoid cascading errors.  If this returns false,
514   // and REASON is not NULL, it may set *REASON.
515   static bool
516   are_identical(const Type* lhs, const Type* rhs, bool errors_are_identical,
517                 std::string* reason);
518
519   // Return true if two types are compatible for use in a binary
520   // operation, other than a shift, comparison, or channel send.  This
521   // is an equivalence relation.
522   static bool
523   are_compatible_for_binop(const Type* t1, const Type* t2);
524
525   // Return true if two types are compatible for use with the
526   // comparison operator.  IS_EQUALITY_OP is true if this is an
527   // equality comparison, false if it is an ordered comparison.  This
528   // is an equivalence relation.  If this returns false, and REASON is
529   // not NULL, it sets *REASON.
530   static bool
531   are_compatible_for_comparison(bool is_equality_op, const Type *t1,
532                                 const Type *t2, std::string* reason);
533
534   // Return true if a type is comparable with itself.  This is true of
535   // most types, but false for, e.g., function types.
536   bool
537   is_comparable() const
538   { return Type::are_compatible_for_comparison(true, this, this, NULL); }
539
540   // Return true if a value with type RHS is assignable to a variable
541   // with type LHS.  This is not an equivalence relation.  If this
542   // returns false, and REASON is not NULL, it sets *REASON.
543   static bool
544   are_assignable(const Type* lhs, const Type* rhs, std::string* reason);
545
546   // Return true if a value with type RHS is assignable to a variable
547   // with type LHS, ignoring any assignment of hidden fields
548   // (unexported fields of a type imported from another package).
549   // This is like the are_assignable method.
550   static bool
551   are_assignable_hidden_ok(const Type* lhs, const Type* rhs,
552                            std::string* reason);
553
554   // Return true if a value with type RHS may be converted to type
555   // LHS.  If this returns false, and REASON is not NULL, it sets
556   // *REASON.
557   static bool
558   are_convertible(const Type* lhs, const Type* rhs, std::string* reason);
559
560   // Whether this type has any hidden fields which are not visible in
561   // the current compilation, such as a field whose name begins with a
562   // lower case letter in a struct imported from a different package.
563   // WITHIN is not NULL if we are looking at fields in a named type.
564   bool
565   has_hidden_fields(const Named_type* within, std::string* reason) const;
566
567   // Return true if values of this type can be compared using an
568   // identity function which gets nothing but a pointer to the value
569   // and a size.
570   bool
571   compare_is_identity() const
572   { return this->do_compare_is_identity(); }
573
574   // Return a hash code for this type for the method hash table.
575   // Types which are equivalent according to are_identical will have
576   // the same hash code.
577   unsigned int
578   hash_for_method(Gogo*) const;
579
580   // Return the type classification.
581   Type_classification
582   classification() const
583   { return this->classification_; }
584
585   // Return the base type for this type.  This looks through forward
586   // declarations and names.  Using this with a forward declaration
587   // which has not been defined will return an error type.
588   Type*
589   base();
590
591   const Type*
592   base() const;
593
594   // Return the type skipping defined forward declarations.  If this
595   // type is a forward declaration which has not been defined, it will
596   // return the Forward_declaration_type.  This differs from base() in
597   // that it will return a Named_type, and for a
598   // Forward_declaration_type which is not defined it will return that
599   // type rather than an error type.
600   Type*
601   forwarded();
602
603   const Type*
604   forwarded() const;
605
606   // Return true if this is a basic type: a type which is not composed
607   // of other types, and is not void.
608   bool
609   is_basic_type() const;
610
611   // Return true if this is an abstract type--an integer, floating
612   // point, or complex type whose size has not been determined.
613   bool
614   is_abstract() const;
615
616   // Return a non-abstract version of an abstract type.
617   Type*
618   make_non_abstract_type();
619
620   // Return true if this type is or contains a pointer.  This
621   // determines whether the garbage collector needs to look at a value
622   // of this type.
623   bool
624   has_pointer() const
625   { return this->do_has_pointer(); }
626
627   // Return true if this is the error type.  This returns false for a
628   // type which is not defined, as it is called by the parser before
629   // all types are defined.
630   bool
631   is_error_type() const;
632
633   // Return true if this is the error type or if the type is
634   // undefined.  If the type is undefined, this will give an error.
635   // This should only be called after parsing is complete.
636   bool
637   is_error() const
638   { return this->base()->is_error_type(); }
639
640   // Return true if this is a void type.
641   bool
642   is_void_type() const
643   { return this->classification_ == TYPE_VOID; }
644
645   // If this is an integer type, return the Integer_type.  Otherwise,
646   // return NULL.  This is a controlled dynamic_cast.
647   Integer_type*
648   integer_type()
649   { return this->convert<Integer_type, TYPE_INTEGER>(); }
650
651   const Integer_type*
652   integer_type() const
653   { return this->convert<const Integer_type, TYPE_INTEGER>(); }
654
655   // If this is a floating point type, return the Float_type.
656   // Otherwise, return NULL.  This is a controlled dynamic_cast.
657   Float_type*
658   float_type()
659   { return this->convert<Float_type, TYPE_FLOAT>(); }
660
661   const Float_type*
662   float_type() const
663   { return this->convert<const Float_type, TYPE_FLOAT>(); }
664
665   // If this is a complex type, return the Complex_type.  Otherwise,
666   // return NULL.
667   Complex_type*
668   complex_type()
669   { return this->convert<Complex_type, TYPE_COMPLEX>(); }
670
671   const Complex_type*
672   complex_type() const
673   { return this->convert<const Complex_type, TYPE_COMPLEX>(); }
674
675   // Return true if this is a boolean type.
676   bool
677   is_boolean_type() const
678   { return this->base()->classification_ == TYPE_BOOLEAN; }
679
680   // Return true if this is an abstract boolean type.
681   bool
682   is_abstract_boolean_type() const
683   { return this->classification_ == TYPE_BOOLEAN; }
684
685   // Return true if this is a string type.
686   bool
687   is_string_type() const
688   { return this->base()->classification_ == TYPE_STRING; }
689
690   // Return true if this is an abstract string type.
691   bool
692   is_abstract_string_type() const
693   { return this->classification_ == TYPE_STRING; }
694
695   // Return true if this is the sink type.  This is the type of the
696   // blank identifier _.
697   bool
698   is_sink_type() const
699   { return this->base()->classification_ == TYPE_SINK; }
700
701   // If this is a function type, return it.  Otherwise, return NULL.
702   Function_type*
703   function_type()
704   { return this->convert<Function_type, TYPE_FUNCTION>(); }
705
706   const Function_type*
707   function_type() const
708   { return this->convert<const Function_type, TYPE_FUNCTION>(); }
709
710   // If this is a pointer type, return the type to which it points.
711   // Otherwise, return NULL.
712   Type*
713   points_to() const;
714
715   // If this is a pointer type, return the type to which it points.
716   // Otherwise, return the type itself.
717   Type*
718   deref()
719   {
720     Type* pt = this->points_to();
721     return pt != NULL ? pt : this;
722   }
723
724   const Type*
725   deref() const
726   {
727     const Type* pt = this->points_to();
728     return pt != NULL ? pt : this;
729   }
730
731   // Return true if this is the nil type.  We don't use base() here,
732   // because this can be called during parse, and there is no way to
733   // name the nil type anyhow.
734   bool
735   is_nil_type() const
736   { return this->classification_ == TYPE_NIL; }
737
738   // Return true if this is the predeclared constant nil being used as
739   // a type.  This is what the parser produces for type switches which
740   // use "case nil".
741   bool
742   is_nil_constant_as_type() const;
743
744   // Return true if this is the return type of a function which
745   // returns multiple values.
746   bool
747   is_call_multiple_result_type() const
748   { return this->base()->classification_ == TYPE_CALL_MULTIPLE_RESULT; }
749
750   // If this is a struct type, return it.  Otherwise, return NULL.
751   Struct_type*
752   struct_type()
753   { return this->convert<Struct_type, TYPE_STRUCT>(); }
754
755   const Struct_type*
756   struct_type() const
757   { return this->convert<const Struct_type, TYPE_STRUCT>(); }
758
759   // If this is an array type, return it.  Otherwise, return NULL.
760   Array_type*
761   array_type()
762   { return this->convert<Array_type, TYPE_ARRAY>(); }
763
764   const Array_type*
765   array_type() const
766   { return this->convert<const Array_type, TYPE_ARRAY>(); }
767
768   // Return whether if this is a slice type.
769   bool
770   is_slice_type() const;
771
772   // If this is a map type, return it.  Otherwise, return NULL.
773   Map_type*
774   map_type()
775   { return this->convert<Map_type, TYPE_MAP>(); }
776
777   const Map_type*
778   map_type() const
779   { return this->convert<const Map_type, TYPE_MAP>(); }
780
781   // If this is a channel type, return it.  Otherwise, return NULL.
782   Channel_type*
783   channel_type()
784   { return this->convert<Channel_type, TYPE_CHANNEL>(); }
785
786   const Channel_type*
787   channel_type() const
788   { return this->convert<const Channel_type, TYPE_CHANNEL>(); }
789
790   // If this is an interface type, return it.  Otherwise, return NULL.
791   Interface_type*
792   interface_type()
793   { return this->convert<Interface_type, TYPE_INTERFACE>(); }
794
795   const Interface_type*
796   interface_type() const
797   { return this->convert<const Interface_type, TYPE_INTERFACE>(); }
798
799   // If this is a named type, return it.  Otherwise, return NULL.
800   Named_type*
801   named_type();
802
803   const Named_type*
804   named_type() const;
805
806   // If this is a forward declaration, return it.  Otherwise, return
807   // NULL.
808   Forward_declaration_type*
809   forward_declaration_type()
810   { return this->convert_no_base<Forward_declaration_type, TYPE_FORWARD>(); }
811
812   const Forward_declaration_type*
813   forward_declaration_type() const
814   {
815     return this->convert_no_base<const Forward_declaration_type,
816                                  TYPE_FORWARD>();
817   }
818
819   // Return true if this type is not yet defined.
820   bool
821   is_undefined() const;
822
823   // Return true if this is the unsafe.pointer type.  We currently
824   // represent that as pointer-to-void.
825   bool
826   is_unsafe_pointer_type() const
827   { return this->points_to() != NULL && this->points_to()->is_void_type(); }
828
829   // Look for field or method NAME for TYPE.  Return an expression for
830   // it, bound to EXPR.
831   static Expression*
832   bind_field_or_method(Gogo*, const Type* type, Expression* expr,
833                        const std::string& name, Location);
834
835   // Return true if NAME is an unexported field or method of TYPE.
836   static bool
837   is_unexported_field_or_method(Gogo*, const Type*, const std::string&,
838                                 std::vector<const Named_type*>*);
839
840   // Convert the builtin named types.
841   static void
842   convert_builtin_named_types(Gogo*);
843
844   // Return the backend representation of this type.
845   Btype*
846   get_backend(Gogo*);
847
848   // Build a type descriptor entry for this type.  Return a pointer to
849   // it.  The location is the location which causes us to need the
850   // entry.
851   tree
852   type_descriptor_pointer(Gogo* gogo, Location);
853
854   // Return the type reflection string for this type.
855   std::string
856   reflection(Gogo*) const;
857
858   // Return a mangled name for the type.  This is a name which can be
859   // used in assembler code.  Identical types should have the same
860   // manged name.
861   std::string
862   mangled_name(Gogo*) const;
863
864   // Get the hash and equality functions for a type.
865   void
866   type_functions(Gogo*, Named_type* name, Function_type* hash_fntype,
867                  Function_type* equal_fntype, Named_object** hash_fn,
868                  Named_object** equal_fn);
869
870   // Write the hash and equality type functions.
871   void
872   write_specific_type_functions(Gogo*, Named_type*,
873                                 const std::string& hash_name,
874                                 Function_type* hash_fntype,
875                                 const std::string& equal_name,
876                                 Function_type* equal_fntype);
877
878   // Export the type.
879   void
880   export_type(Export* exp) const
881   { this->do_export(exp); }
882
883   // Import a type.
884   static Type*
885   import_type(Import*);
886
887  protected:
888   Type(Type_classification);
889
890   // Functions implemented by the child class.
891
892   // Traverse the subtypes.
893   virtual int
894   do_traverse(Traverse*);
895
896   // Verify the type.
897   virtual bool
898   do_verify()
899   { return true; }
900
901   virtual bool
902   do_has_pointer() const
903   { return false; }
904
905   virtual bool
906   do_compare_is_identity() const = 0;
907
908   virtual unsigned int
909   do_hash_for_method(Gogo*) const;
910
911   virtual Btype*
912   do_get_backend(Gogo*) = 0;
913
914   virtual Expression*
915   do_type_descriptor(Gogo*, Named_type* name) = 0;
916
917   virtual void
918   do_reflection(Gogo*, std::string*) const = 0;
919
920   virtual void
921   do_mangled_name(Gogo*, std::string*) const = 0;
922
923   virtual void
924   do_export(Export*) const;
925
926   // Return whether a method expects a pointer as the receiver.
927   static bool
928   method_expects_pointer(const Named_object*);
929
930   // Finalize the methods for a type.
931   static void
932   finalize_methods(Gogo*, const Type*, Location, Methods**);
933
934   // Return a method from a set of methods.
935   static Method*
936   method_function(const Methods*, const std::string& name,
937                   bool* is_ambiguous);
938
939   // Return a composite literal for the type descriptor entry for a
940   // type.
941   static Expression*
942   type_descriptor(Gogo*, Type*);
943
944   // Return a composite literal for the type descriptor entry for
945   // TYPE, using NAME as the name of the type.
946   static Expression*
947   named_type_descriptor(Gogo*, Type* type, Named_type* name);
948
949   // Return a composite literal for a plain type descriptor for this
950   // type with the given kind and name.
951   Expression*
952   plain_type_descriptor(Gogo*, int runtime_type_kind, Named_type* name);
953
954   // Build a composite literal for the basic type descriptor.
955   Expression*
956   type_descriptor_constructor(Gogo*, int runtime_type_kind, Named_type*,
957                               const Methods*, bool only_value_methods);
958
959   // Make a builtin struct type from a list of fields.
960   static Struct_type*
961   make_builtin_struct_type(int nfields, ...);
962
963   // Make a builtin named type.
964   static Named_type*
965   make_builtin_named_type(const char* name, Type* type);
966
967   // For the benefit of child class reflection string generation.
968   void
969   append_reflection(const Type* type, Gogo* gogo, std::string* ret) const
970   { type->do_reflection(gogo, ret); }
971
972   // For the benefit of child class mangling.
973   void
974   append_mangled_name(const Type* type, Gogo* gogo, std::string* ret) const
975   { type->do_mangled_name(gogo, ret); }
976
977   // Incorporate a string into a hash code.
978   static unsigned int
979   hash_string(const std::string&, unsigned int);
980
981   // Return the backend representation for the underlying type of a
982   // named type.
983   static Btype*
984   get_named_base_btype(Gogo* gogo, Type* base_type)
985   { return base_type->get_btype_without_hash(gogo); }
986
987  private:
988   // Convert to the desired type classification, or return NULL.  This
989   // is a controlled dynamic_cast.
990   template<typename Type_class, Type_classification type_classification>
991   Type_class*
992   convert()
993   {
994     Type* base = this->base();
995     return (base->classification_ == type_classification
996             ? static_cast<Type_class*>(base)
997             : NULL);
998   }
999
1000   template<typename Type_class, Type_classification type_classification>
1001   const Type_class*
1002   convert() const
1003   {
1004     const Type* base = this->base();
1005     return (base->classification_ == type_classification
1006             ? static_cast<Type_class*>(base)
1007             : NULL);
1008   }
1009
1010   template<typename Type_class, Type_classification type_classification>
1011   Type_class*
1012   convert_no_base()
1013   {
1014     return (this->classification_ == type_classification
1015             ? static_cast<Type_class*>(this)
1016             : NULL);
1017   }
1018
1019   template<typename Type_class, Type_classification type_classification>
1020   const Type_class*
1021   convert_no_base() const
1022   {
1023     return (this->classification_ == type_classification
1024             ? static_cast<Type_class*>(this)
1025             : NULL);
1026   }
1027
1028   // Support for are_assignable and are_assignable_hidden_ok.
1029   static bool
1030   are_assignable_check_hidden(const Type* lhs, const Type* rhs,
1031                               bool check_hidden_fields, std::string* reason);
1032
1033   // Map unnamed types to type descriptor decls.
1034   typedef Unordered_map_hash(const Type*, Bvariable*, Type_hash_identical,
1035                              Type_identical) Type_descriptor_vars;
1036
1037   static Type_descriptor_vars type_descriptor_vars;
1038
1039   // Build the type descriptor variable for this type.
1040   void
1041   make_type_descriptor_var(Gogo*);
1042
1043   // Return the name of the type descriptor variable.  If NAME is not
1044   // NULL, it is the name to use.
1045   std::string
1046   type_descriptor_var_name(Gogo*, Named_type* name);
1047
1048   // Return true if the type descriptor for this type should be
1049   // defined in some other package.  If NAME is not NULL, it is the
1050   // name of this type.  If this returns true it sets *PACKAGE to the
1051   // package where the type descriptor is defined.
1052   bool
1053   type_descriptor_defined_elsewhere(Named_type* name, const Package** package);
1054
1055   // Build the hash and equality type functions for a type which needs
1056   // specific functions.
1057   void
1058   specific_type_functions(Gogo*, Named_type*, Function_type* hash_fntype,
1059                           Function_type* equal_fntype, Named_object** hash_fn,
1060                           Named_object** equal_fn);
1061
1062   // Build a composite literal for the uncommon type information.
1063   Expression*
1064   uncommon_type_constructor(Gogo*, Type* uncommon_type,
1065                             Named_type*, const Methods*,
1066                             bool only_value_methods) const;
1067
1068   // Build a composite literal for the methods.
1069   Expression*
1070   methods_constructor(Gogo*, Type* methods_type, const Methods*,
1071                       bool only_value_methods) const;
1072
1073   // Build a composite literal for one method.
1074   Expression*
1075   method_constructor(Gogo*, Type* method_type, const std::string& name,
1076                      const Method*, bool only_value_methods) const;
1077
1078   static tree
1079   build_receive_return_type(tree type);
1080
1081   // A hash table we use to avoid infinite recursion.
1082   typedef Unordered_set_hash(const Named_type*, Type_hash_identical,
1083                              Type_identical) Types_seen;
1084
1085   // Add all methods for TYPE to the list of methods for THIS.
1086   static void
1087   add_methods_for_type(const Type* type, const Method::Field_indexes*,
1088                        unsigned int depth, bool, bool, Types_seen*,
1089                        Methods**);
1090
1091   static void
1092   add_local_methods_for_type(const Named_type* type,
1093                              const Method::Field_indexes*,
1094                              unsigned int depth, bool, bool, Methods**);
1095
1096   static void
1097   add_embedded_methods_for_type(const Type* type,
1098                                 const Method::Field_indexes*,
1099                                 unsigned int depth, bool, bool, Types_seen*,
1100                                 Methods**);
1101
1102   static void
1103   add_interface_methods_for_type(const Type* type,
1104                                  const Method::Field_indexes*,
1105                                  unsigned int depth, Methods**);
1106
1107   // Build stub methods for a type.
1108   static void
1109   build_stub_methods(Gogo*, const Type* type, const Methods* methods,
1110                      Location);
1111
1112   static void
1113   build_one_stub_method(Gogo*, Method*, const char* receiver_name,
1114                         const Typed_identifier_list*, bool is_varargs,
1115                         Location);
1116
1117   static Expression*
1118   apply_field_indexes(Expression*, const Method::Field_indexes*,
1119                       Location);
1120
1121   // Look for a field or method named NAME in TYPE.
1122   static bool
1123   find_field_or_method(const Type* type, const std::string& name,
1124                        bool receiver_can_be_pointer,
1125                        std::vector<const Named_type*>*, int* level,
1126                        bool* is_method, bool* found_pointer_method,
1127                        std::string* ambig1, std::string* ambig2);
1128
1129   // Get the backend representation for a type without looking in the
1130   // hash table for identical types.
1131   Btype*
1132   get_btype_without_hash(Gogo*);
1133
1134   // A mapping from Type to Btype*, used to ensure that the backend
1135   // representation of identical types is identical.
1136   typedef Unordered_map_hash(const Type*, Btype*, Type_hash_identical,
1137                              Type_identical) Type_btypes;
1138
1139   static Type_btypes type_btypes;
1140
1141   // A list of builtin named types.
1142   static std::vector<Named_type*> named_builtin_types;
1143
1144   // A map from types which need specific type functions to the type
1145   // functions themselves.
1146   typedef std::pair<Named_object*, Named_object*> Hash_equal_fn;
1147   typedef Unordered_map_hash(const Type*, Hash_equal_fn, Type_hash_identical,
1148                              Type_identical) Type_functions;
1149
1150   static Type_functions type_functions_table;
1151
1152   // The type classification.
1153   Type_classification classification_;
1154   // The backend representation of the type, once it has been
1155   // determined.
1156   Btype* btype_;
1157   // The type descriptor for this type.  This starts out as NULL and
1158   // is filled in as needed.
1159   Bvariable* type_descriptor_var_;
1160 };
1161
1162 // Type hash table operations.
1163
1164 class Type_hash_identical
1165 {
1166  public:
1167   unsigned int
1168   operator()(const Type* type) const
1169   { return type->hash_for_method(NULL); }
1170 };
1171
1172 class Type_identical
1173 {
1174  public:
1175   bool
1176   operator()(const Type* t1, const Type* t2) const
1177   { return Type::are_identical(t1, t2, false, NULL); }
1178 };
1179
1180 // An identifier with a type.
1181
1182 class Typed_identifier
1183 {
1184  public:
1185   Typed_identifier(const std::string& name, Type* type,
1186                    Location location)
1187     : name_(name), type_(type), location_(location)
1188   { }
1189
1190   // Get the name.
1191   const std::string&
1192   name() const
1193   { return this->name_; }
1194
1195   // Get the type.
1196   Type*
1197   type() const
1198   { return this->type_; }
1199
1200   // Return the location where the name was seen.  This is not always
1201   // meaningful.
1202   Location
1203   location() const
1204   { return this->location_; }
1205
1206   // Set the type--sometimes we see the identifier before the type.
1207   void
1208   set_type(Type* type)
1209   {
1210     go_assert(this->type_ == NULL || type->is_error_type());
1211     this->type_ = type;
1212   }
1213
1214  private:
1215   // Identifier name.
1216   std::string name_;
1217   // Type.
1218   Type* type_;
1219   // The location where the name was seen.
1220   Location location_;
1221 };
1222
1223 // A list of Typed_identifiers.
1224
1225 class Typed_identifier_list
1226 {
1227  public:
1228   Typed_identifier_list()
1229     : entries_()
1230   { }
1231
1232   // Whether the list is empty.
1233   bool
1234   empty() const
1235   { return this->entries_.empty(); }
1236
1237   // Return the number of entries in the list.
1238   size_t
1239   size() const
1240   { return this->entries_.size(); }
1241
1242   // Add an entry to the end of the list.
1243   void
1244   push_back(const Typed_identifier& td)
1245   { this->entries_.push_back(td); }
1246
1247   // Remove an entry from the end of the list.
1248   void
1249   pop_back()
1250   { this->entries_.pop_back(); }
1251
1252   // Set the type of entry I to TYPE.
1253   void
1254   set_type(size_t i, Type* type)
1255   {
1256     go_assert(i < this->entries_.size());
1257     this->entries_[i].set_type(type);
1258   }
1259
1260   // Sort the entries by name.
1261   void
1262   sort_by_name();
1263
1264   // Traverse types.
1265   int
1266   traverse(Traverse*);
1267
1268   // Return the first and last elements.
1269   Typed_identifier&
1270   front()
1271   { return this->entries_.front(); }
1272
1273   const Typed_identifier&
1274   front() const
1275   { return this->entries_.front(); }
1276
1277   Typed_identifier&
1278   back()
1279   { return this->entries_.back(); }
1280
1281   const Typed_identifier&
1282   back() const
1283   { return this->entries_.back(); }
1284
1285   const Typed_identifier&
1286   at(size_t i) const
1287   { return this->entries_.at(i); }
1288
1289   void
1290   set(size_t i, const Typed_identifier& t)
1291   { this->entries_.at(i) = t; }
1292
1293   void
1294   resize(size_t c)
1295   {
1296     go_assert(c <= this->entries_.size());
1297     this->entries_.resize(c, Typed_identifier("", NULL,
1298                                               Linemap::unknown_location()));
1299   }
1300
1301   // Iterators.
1302
1303   typedef std::vector<Typed_identifier>::iterator iterator;
1304   typedef std::vector<Typed_identifier>::const_iterator const_iterator;
1305
1306   iterator
1307   begin()
1308   { return this->entries_.begin(); }
1309
1310   const_iterator
1311   begin() const
1312   { return this->entries_.begin(); }
1313
1314   iterator
1315   end()
1316   { return this->entries_.end(); }
1317
1318   const_iterator
1319   end() const
1320   { return this->entries_.end(); }
1321
1322   // Return a copy of this list.  This returns an independent copy of
1323   // the vector, but does not copy the types.
1324   Typed_identifier_list*
1325   copy() const;
1326
1327  private:
1328   std::vector<Typed_identifier> entries_;
1329 };
1330
1331 // The type of an integer.
1332
1333 class Integer_type : public Type
1334 {
1335  public:
1336   // Create a new integer type.
1337   static Named_type*
1338   create_integer_type(const char* name, bool is_unsigned, int bits,
1339                       int runtime_type_kind);
1340
1341   // Look up an existing integer type.
1342   static Named_type*
1343   lookup_integer_type(const char* name);
1344
1345   // Create an abstract integer type.
1346   static Integer_type*
1347   create_abstract_integer_type();
1348
1349   // Whether this is an abstract integer type.
1350   bool
1351   is_abstract() const
1352   { return this->is_abstract_; }
1353
1354   // Whether this is an unsigned type.
1355   bool
1356   is_unsigned() const
1357   { return this->is_unsigned_; }
1358
1359   // The number of bits.
1360   int
1361   bits() const
1362   { return this->bits_; }
1363
1364   // Whether this type is the same as T.
1365   bool
1366   is_identical(const Integer_type* t) const;
1367
1368  protected:
1369   bool
1370   do_compare_is_identity() const
1371   { return true; }
1372
1373   unsigned int
1374   do_hash_for_method(Gogo*) const;
1375
1376   Btype*
1377   do_get_backend(Gogo*);
1378
1379   Expression*
1380   do_type_descriptor(Gogo*, Named_type*);
1381
1382   void
1383   do_reflection(Gogo*, std::string*) const;
1384
1385   void
1386   do_mangled_name(Gogo*, std::string*) const;
1387
1388  private:
1389   Integer_type(bool is_abstract, bool is_unsigned, int bits,
1390                int runtime_type_kind)
1391     : Type(TYPE_INTEGER),
1392       is_abstract_(is_abstract), is_unsigned_(is_unsigned), bits_(bits),
1393       runtime_type_kind_(runtime_type_kind)
1394   { }
1395
1396   // Map names of integer types to the types themselves.
1397   typedef std::map<std::string, Named_type*> Named_integer_types;
1398   static Named_integer_types named_integer_types;
1399
1400   // True if this is an abstract type.
1401   bool is_abstract_;
1402   // True if this is an unsigned type.
1403   bool is_unsigned_;
1404   // The number of bits.
1405   int bits_;
1406   // The runtime type code used in the type descriptor for this type.
1407   int runtime_type_kind_;
1408 };
1409
1410 // The type of a floating point number.
1411
1412 class Float_type : public Type
1413 {
1414  public:
1415   // Create a new float type.
1416   static Named_type*
1417   create_float_type(const char* name, int bits, int runtime_type_kind);
1418
1419   // Look up an existing float type.
1420   static Named_type*
1421   lookup_float_type(const char* name);
1422
1423   // Create an abstract float type.
1424   static Float_type*
1425   create_abstract_float_type();
1426
1427   // Whether this is an abstract float type.
1428   bool
1429   is_abstract() const
1430   { return this->is_abstract_; }
1431
1432   // The number of bits.
1433   int
1434   bits() const
1435   { return this->bits_; }
1436
1437   // Whether this type is the same as T.
1438   bool
1439   is_identical(const Float_type* t) const;
1440
1441  protected:
1442   bool
1443   do_compare_is_identity() const
1444   { return false; }
1445
1446   unsigned int
1447   do_hash_for_method(Gogo*) const;
1448
1449   Btype*
1450   do_get_backend(Gogo*);
1451
1452   Expression*
1453   do_type_descriptor(Gogo*, Named_type*);
1454
1455   void
1456   do_reflection(Gogo*, std::string*) const;
1457
1458   void
1459   do_mangled_name(Gogo*, std::string*) const;
1460
1461  private:
1462   Float_type(bool is_abstract, int bits, int runtime_type_kind)
1463     : Type(TYPE_FLOAT),
1464       is_abstract_(is_abstract), bits_(bits),
1465       runtime_type_kind_(runtime_type_kind)
1466   { }
1467
1468   // Map names of float types to the types themselves.
1469   typedef std::map<std::string, Named_type*> Named_float_types;
1470   static Named_float_types named_float_types;
1471
1472   // True if this is an abstract type.
1473   bool is_abstract_;
1474   // The number of bits in the floating point value.
1475   int bits_;
1476   // The runtime type code used in the type descriptor for this type.
1477   int runtime_type_kind_;
1478 };
1479
1480 // The type of a complex number.
1481
1482 class Complex_type : public Type
1483 {
1484  public:
1485   // Create a new complex type.
1486   static Named_type*
1487   create_complex_type(const char* name, int bits, int runtime_type_kind);
1488
1489   // Look up an existing complex type.
1490   static Named_type*
1491   lookup_complex_type(const char* name);
1492
1493   // Create an abstract complex type.
1494   static Complex_type*
1495   create_abstract_complex_type();
1496
1497   // Whether this is an abstract complex type.
1498   bool
1499   is_abstract() const
1500   { return this->is_abstract_; }
1501
1502   // The number of bits: 64 or 128.
1503   int bits() const
1504   { return this->bits_; }
1505
1506   // Whether this type is the same as T.
1507   bool
1508   is_identical(const Complex_type* t) const;
1509
1510  protected:
1511   bool
1512   do_compare_is_identity() const
1513   { return false; }
1514
1515   unsigned int
1516   do_hash_for_method(Gogo*) const;
1517
1518   Btype*
1519   do_get_backend(Gogo*);
1520
1521   Expression*
1522   do_type_descriptor(Gogo*, Named_type*);
1523
1524   void
1525   do_reflection(Gogo*, std::string*) const;
1526
1527   void
1528   do_mangled_name(Gogo*, std::string*) const;
1529
1530  private:
1531   Complex_type(bool is_abstract, int bits, int runtime_type_kind)
1532     : Type(TYPE_COMPLEX),
1533       is_abstract_(is_abstract), bits_(bits),
1534       runtime_type_kind_(runtime_type_kind)
1535   { }
1536
1537   // Map names of complex types to the types themselves.
1538   typedef std::map<std::string, Named_type*> Named_complex_types;
1539   static Named_complex_types named_complex_types;
1540
1541   // True if this is an abstract type.
1542   bool is_abstract_;
1543   // The number of bits in the complex value--64 or 128.
1544   int bits_;
1545   // The runtime type code used in the type descriptor for this type.
1546   int runtime_type_kind_;
1547 };
1548
1549 // The type of a string.
1550
1551 class String_type : public Type
1552 {
1553  public:
1554   String_type()
1555     : Type(TYPE_STRING)
1556   { }
1557
1558   // Return a tree for the length of STRING.
1559   static tree
1560   length_tree(Gogo*, tree string);
1561
1562   // Return a tree which points to the bytes of STRING.
1563   static tree
1564   bytes_tree(Gogo*, tree string);
1565
1566  protected:
1567   bool
1568   do_has_pointer() const
1569   { return true; }
1570
1571   bool
1572   do_compare_is_identity() const
1573   { return false; }
1574
1575   Btype*
1576   do_get_backend(Gogo*);
1577
1578   Expression*
1579   do_type_descriptor(Gogo*, Named_type*);
1580
1581   void
1582   do_reflection(Gogo*, std::string*) const;
1583
1584   void
1585   do_mangled_name(Gogo*, std::string* ret) const;
1586
1587  private:
1588   // The named string type.
1589   static Named_type* string_type_;
1590 };
1591
1592 // The type of a function.
1593
1594 class Function_type : public Type
1595 {
1596  public:
1597   Function_type(Typed_identifier* receiver, Typed_identifier_list* parameters,
1598                 Typed_identifier_list* results, Location location)
1599     : Type(TYPE_FUNCTION),
1600       receiver_(receiver), parameters_(parameters), results_(results),
1601       location_(location), is_varargs_(false), is_builtin_(false)
1602   { }
1603
1604   // Get the receiver.
1605   const Typed_identifier*
1606   receiver() const
1607   { return this->receiver_; }
1608
1609   // Get the return names and types.
1610   const Typed_identifier_list*
1611   results() const
1612   { return this->results_; }
1613
1614   // Get the parameter names and types.
1615   const Typed_identifier_list*
1616   parameters() const
1617   { return this->parameters_; }
1618
1619   // Whether this is a varargs function.
1620   bool
1621   is_varargs() const
1622   { return this->is_varargs_; }
1623
1624   // Whether this is a builtin function.
1625   bool
1626   is_builtin() const
1627   { return this->is_builtin_; }
1628
1629   // The location where this type was defined.
1630   Location
1631   location() const
1632   { return this->location_; }
1633
1634   // Return whether this is a method type.
1635   bool
1636   is_method() const
1637   { return this->receiver_ != NULL; }
1638
1639   // Whether T is a valid redeclaration of this type.  This is called
1640   // when a function is declared more than once.
1641   bool
1642   is_valid_redeclaration(const Function_type* t, std::string*) const;
1643
1644   // Whether this type is the same as T.
1645   bool
1646   is_identical(const Function_type* t, bool ignore_receiver,
1647                bool errors_are_identical, std::string*) const;
1648
1649   // Record that this is a varargs function.
1650   void
1651   set_is_varargs()
1652   { this->is_varargs_ = true; }
1653
1654   // Record that this is a builtin function.
1655   void
1656   set_is_builtin()
1657   { this->is_builtin_ = true; }
1658
1659   // Import a function type.
1660   static Function_type*
1661   do_import(Import*);
1662
1663   // Return a copy of this type without a receiver.  This is only
1664   // valid for a method type.
1665   Function_type*
1666   copy_without_receiver() const;
1667
1668   // Return a copy of this type with a receiver.  This is used when an
1669   // interface method is attached to a named or struct type.
1670   Function_type*
1671   copy_with_receiver(Type*) const;
1672
1673   // Finishing converting function types.
1674   static void
1675   convert_types(Gogo*);
1676
1677   static Type*
1678   make_function_type_descriptor_type();
1679
1680  protected:
1681   int
1682   do_traverse(Traverse*);
1683
1684   // A trampoline function has a pointer which matters for GC.
1685   bool
1686   do_has_pointer() const
1687   { return true; }
1688
1689   bool
1690   do_compare_is_identity() const
1691   { return false; }
1692
1693   unsigned int
1694   do_hash_for_method(Gogo*) const;
1695
1696   Btype*
1697   do_get_backend(Gogo*);
1698
1699   Expression*
1700   do_type_descriptor(Gogo*, Named_type*);
1701
1702   void
1703   do_reflection(Gogo*, std::string*) const;
1704
1705   void
1706   do_mangled_name(Gogo*, std::string*) const;
1707
1708   void
1709   do_export(Export*) const;
1710
1711  private:
1712   Expression*
1713   type_descriptor_params(Type*, const Typed_identifier*,
1714                          const Typed_identifier_list*);
1715
1716   Btype*
1717   get_function_backend(Gogo*);
1718
1719   // A list of function types with multiple results and their
1720   // placeholder backend representations, used to postpone building
1721   // the structs we use for multiple results until all types are
1722   // converted.
1723   typedef std::vector<std::pair<Function_type*, Btype*> > Placeholders;
1724   static Placeholders placeholders;
1725
1726   // The receiver name and type.  This will be NULL for a normal
1727   // function, non-NULL for a method.
1728   Typed_identifier* receiver_;
1729   // The parameter names and types.
1730   Typed_identifier_list* parameters_;
1731   // The result names and types.  This will be NULL if no result was
1732   // specified.
1733   Typed_identifier_list* results_;
1734   // The location where this type was defined.  This exists solely to
1735   // give a location for the fields of the struct if this function
1736   // returns multiple values.
1737   Location location_;
1738   // Whether this function takes a variable number of arguments.
1739   bool is_varargs_;
1740   // Whether this is a special builtin function which can not simply
1741   // be called.  This is used for len, cap, etc.
1742   bool is_builtin_;
1743 };
1744
1745 // The type of a pointer.
1746
1747 class Pointer_type : public Type
1748 {
1749  public:
1750   Pointer_type(Type* to_type)
1751     : Type(TYPE_POINTER),
1752       to_type_(to_type)
1753   {}
1754
1755   Type*
1756   points_to() const
1757   { return this->to_type_; }
1758
1759   // Import a pointer type.
1760   static Pointer_type*
1761   do_import(Import*);
1762
1763   static Type*
1764   make_pointer_type_descriptor_type();
1765
1766  protected:
1767   int
1768   do_traverse(Traverse*);
1769
1770   bool
1771   do_has_pointer() const
1772   { return true; }
1773
1774   bool
1775   do_compare_is_identity() const
1776   { return true; }
1777
1778   unsigned int
1779   do_hash_for_method(Gogo*) const;
1780
1781   Btype*
1782   do_get_backend(Gogo*);
1783
1784   Expression*
1785   do_type_descriptor(Gogo*, Named_type*);
1786
1787   void
1788   do_reflection(Gogo*, std::string*) const;
1789
1790   void
1791   do_mangled_name(Gogo*, std::string*) const;
1792
1793   void
1794   do_export(Export*) const;
1795
1796  private:
1797   // The type to which this type points.
1798   Type* to_type_;
1799 };
1800
1801 // The type of a field in a struct.
1802
1803 class Struct_field
1804 {
1805  public:
1806   explicit Struct_field(const Typed_identifier& typed_identifier)
1807     : typed_identifier_(typed_identifier), tag_(NULL)
1808   { }
1809
1810   // The field name.
1811   const std::string&
1812   field_name() const;
1813
1814   // Return whether this struct field is named NAME.
1815   bool
1816   is_field_name(const std::string& name) const;
1817
1818   // The field type.
1819   Type*
1820   type() const
1821   { return this->typed_identifier_.type(); }
1822
1823   // The field location.
1824   Location
1825   location() const
1826   { return this->typed_identifier_.location(); }
1827
1828   // Whether the field has a tag.
1829   bool
1830   has_tag() const
1831   { return this->tag_ != NULL; }
1832
1833   // The tag.
1834   const std::string&
1835   tag() const
1836   {
1837     go_assert(this->tag_ != NULL);
1838     return *this->tag_;
1839   }
1840
1841   // Whether this is an anonymous field.
1842   bool
1843   is_anonymous() const
1844   { return this->typed_identifier_.name().empty(); }
1845
1846   // Set the tag.  FIXME: This is never freed.
1847   void
1848   set_tag(const std::string& tag)
1849   { this->tag_ = new std::string(tag); }
1850
1851   // Set the type.  This is only used in error cases.
1852   void
1853   set_type(Type* type)
1854   { this->typed_identifier_.set_type(type); }
1855
1856  private:
1857   // The field name, type, and location.
1858   Typed_identifier typed_identifier_;
1859   // The field tag.  This is NULL if the field has no tag.
1860   std::string* tag_;
1861 };
1862
1863 // A list of struct fields.
1864
1865 class Struct_field_list
1866 {
1867  public:
1868   Struct_field_list()
1869     : entries_()
1870   { }
1871
1872   // Whether the list is empty.
1873   bool
1874   empty() const
1875   { return this->entries_.empty(); }
1876
1877   // Return the number of entries.
1878   size_t
1879   size() const
1880   { return this->entries_.size(); }
1881
1882   // Add an entry to the end of the list.
1883   void
1884   push_back(const Struct_field& sf)
1885   { this->entries_.push_back(sf); }
1886
1887   // Index into the list.
1888   const Struct_field&
1889   at(size_t i) const
1890   { return this->entries_.at(i); }
1891
1892   // Last entry in list.
1893   Struct_field&
1894   back()
1895   { return this->entries_.back(); }
1896
1897   // Iterators.
1898
1899   typedef std::vector<Struct_field>::iterator iterator;
1900   typedef std::vector<Struct_field>::const_iterator const_iterator;
1901
1902   iterator
1903   begin()
1904   { return this->entries_.begin(); }
1905
1906   const_iterator
1907   begin() const
1908   { return this->entries_.begin(); }
1909
1910   iterator
1911   end()
1912   { return this->entries_.end(); }
1913
1914   const_iterator
1915   end() const
1916   { return this->entries_.end(); }
1917
1918  private:
1919   std::vector<Struct_field> entries_;
1920 };
1921
1922 // The type of a struct.
1923
1924 class Struct_type : public Type
1925 {
1926  public:
1927   Struct_type(Struct_field_list* fields, Location location)
1928     : Type(TYPE_STRUCT),
1929       fields_(fields), location_(location), all_methods_(NULL)
1930   { }
1931
1932   // Return the field NAME.  This only looks at local fields, not at
1933   // embedded types.  If the field is found, and PINDEX is not NULL,
1934   // this sets *PINDEX to the field index.  If the field is not found,
1935   // this returns NULL.
1936   const Struct_field*
1937   find_local_field(const std::string& name, unsigned int *pindex) const;
1938
1939   // Return the field number INDEX.
1940   const Struct_field*
1941   field(unsigned int index) const
1942   { return &this->fields_->at(index); }
1943
1944   // Get the struct fields.
1945   const Struct_field_list*
1946   fields() const
1947   { return this->fields_; }
1948
1949   // Return the number of fields.
1950   size_t
1951   field_count() const
1952   { return this->fields_->size(); }
1953
1954   // Push a new field onto the end of the struct.  This is used when
1955   // building a closure variable.
1956   void
1957   push_field(const Struct_field& sf)
1958   { this->fields_->push_back(sf); }
1959
1960   // Return an expression referring to field NAME in STRUCT_EXPR, or
1961   // NULL if there is no field with that name.
1962   Field_reference_expression*
1963   field_reference(Expression* struct_expr, const std::string& name,
1964                   Location) const;
1965
1966   // Return the total number of fields, including embedded fields.
1967   // This is the number of values which can appear in a conversion to
1968   // this type.
1969   unsigned int
1970   total_field_count() const;
1971
1972   // Whether this type is identical with T.
1973   bool
1974   is_identical(const Struct_type* t, bool errors_are_identical) const;
1975
1976   // Whether this struct type has any hidden fields.  This returns
1977   // true if any fields have hidden names, or if any non-pointer
1978   // anonymous fields have types with hidden fields.
1979   bool
1980   struct_has_hidden_fields(const Named_type* within, std::string*) const;
1981
1982   // Return whether NAME is a local field which is not exported.  This
1983   // is only used for better error reporting.
1984   bool
1985   is_unexported_local_field(Gogo*, const std::string& name) const;
1986
1987   // If this is an unnamed struct, build the complete list of methods,
1988   // including those from anonymous fields, and build methods stubs if
1989   // needed.
1990   void
1991   finalize_methods(Gogo*);
1992
1993   // Return whether this type has any methods.  This should only be
1994   // called after the finalize_methods pass.
1995   bool
1996   has_any_methods() const
1997   { return this->all_methods_ != NULL; }
1998
1999   // Return the methods for tihs type.  This should only be called
2000   // after the finalize_methods pass.
2001   const Methods*
2002   methods() const
2003   { return this->all_methods_; }
2004
2005   // Return the method to use for NAME.  This returns NULL if there is
2006   // no such method or if the method is ambiguous.  When it returns
2007   // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2008   Method*
2009   method_function(const std::string& name, bool* is_ambiguous) const;
2010
2011   // Traverse just the field types of a struct type.
2012   int
2013   traverse_field_types(Traverse* traverse)
2014   { return this->do_traverse(traverse); }
2015
2016   // Import a struct type.
2017   static Struct_type*
2018   do_import(Import*);
2019
2020   static Type*
2021   make_struct_type_descriptor_type();
2022
2023   // Write the hash function for this type.
2024   void
2025   write_hash_function(Gogo*, Named_type*, Function_type*, Function_type*);
2026
2027   // Write the equality function for this type.
2028   void
2029   write_equal_function(Gogo*, Named_type*);
2030
2031  protected:
2032   int
2033   do_traverse(Traverse*);
2034
2035   bool
2036   do_verify();
2037
2038   bool
2039   do_has_pointer() const;
2040
2041   bool
2042   do_compare_is_identity() const;
2043
2044   unsigned int
2045   do_hash_for_method(Gogo*) const;
2046
2047   Btype*
2048   do_get_backend(Gogo*);
2049
2050   Expression*
2051   do_type_descriptor(Gogo*, Named_type*);
2052
2053   void
2054   do_reflection(Gogo*, std::string*) const;
2055
2056   void
2057   do_mangled_name(Gogo*, std::string*) const;
2058
2059   void
2060   do_export(Export*) const;
2061
2062  private:
2063   // Used to avoid infinite loops in field_reference_depth.
2064   struct Saw_named_type
2065   {
2066     Saw_named_type* next;
2067     Named_type* nt;
2068   };
2069
2070   Field_reference_expression*
2071   field_reference_depth(Expression* struct_expr, const std::string& name,
2072                         Location, Saw_named_type*,
2073                         unsigned int* depth) const;
2074
2075   // The fields of the struct.
2076   Struct_field_list* fields_;
2077   // The place where the struct was declared.
2078   Location location_;
2079   // If this struct is unnamed, a list of methods.
2080   Methods* all_methods_;
2081 };
2082
2083 // The type of an array.
2084
2085 class Array_type : public Type
2086 {
2087  public:
2088   Array_type(Type* element_type, Expression* length)
2089     : Type(TYPE_ARRAY),
2090       element_type_(element_type), length_(length), length_tree_(NULL)
2091   { }
2092
2093   // Return the element type.
2094   Type*
2095   element_type() const
2096   { return this->element_type_; }
2097
2098   // Return the length.  This will return NULL for an open array.
2099   Expression*
2100   length() const
2101   { return this->length_; }
2102
2103   // Whether this type is identical with T.
2104   bool
2105   is_identical(const Array_type* t, bool errors_are_identical) const;
2106
2107   // Whether this type has any hidden fields.
2108   bool
2109   array_has_hidden_fields(const Named_type* within, std::string* reason) const
2110   { return this->element_type_->has_hidden_fields(within, reason); }
2111
2112   // Build the hash and equality functions if necessary.
2113   void
2114   finalize_methods(Gogo*);
2115
2116   // Return a tree for the pointer to the values in an array.
2117   tree
2118   value_pointer_tree(Gogo*, tree array) const;
2119
2120   // Return a tree for the length of an array with this type.
2121   tree
2122   length_tree(Gogo*, tree array);
2123
2124   // Return a tree for the capacity of an array with this type.
2125   tree
2126   capacity_tree(Gogo*, tree array);
2127
2128   // Import an array type.
2129   static Array_type*
2130   do_import(Import*);
2131
2132   // Return the backend representation of the element type.
2133   Btype*
2134   get_backend_element(Gogo*);
2135
2136   // Return the backend representation of the length.
2137   Bexpression*
2138   get_backend_length(Gogo*);
2139
2140   static Type*
2141   make_array_type_descriptor_type();
2142
2143   static Type*
2144   make_slice_type_descriptor_type();
2145
2146   // Write the hash function for this type.
2147   void
2148   write_hash_function(Gogo*, Named_type*, Function_type*, Function_type*);
2149
2150   // Write the equality function for this type.
2151   void
2152   write_equal_function(Gogo*, Named_type*);
2153
2154  protected:
2155   int
2156   do_traverse(Traverse* traverse);
2157
2158   bool
2159   do_verify();
2160
2161   bool
2162   do_has_pointer() const
2163   {
2164     return this->length_ == NULL || this->element_type_->has_pointer();
2165   }
2166
2167   bool
2168   do_compare_is_identity() const
2169   {
2170     return (this->length_ != NULL
2171             && this->element_type_->compare_is_identity());
2172   }
2173
2174   unsigned int
2175   do_hash_for_method(Gogo*) const;
2176
2177   Btype*
2178   do_get_backend(Gogo*);
2179
2180   Expression*
2181   do_type_descriptor(Gogo*, Named_type*);
2182
2183   void
2184   do_reflection(Gogo*, std::string*) const;
2185
2186   void
2187   do_mangled_name(Gogo*, std::string*) const;
2188
2189   void
2190   do_export(Export*) const;
2191
2192  private:
2193   bool
2194   verify_length();
2195
2196   tree
2197   get_length_tree(Gogo*);
2198
2199   Expression*
2200   array_type_descriptor(Gogo*, Named_type*);
2201
2202   Expression*
2203   slice_type_descriptor(Gogo*, Named_type*);
2204
2205   // The type of elements of the array.
2206   Type* element_type_;
2207   // The number of elements.  This may be NULL.
2208   Expression* length_;
2209   // The length as a tree.  We only want to compute this once.
2210   tree length_tree_;
2211 };
2212
2213 // The type of a map.
2214
2215 class Map_type : public Type
2216 {
2217  public:
2218   Map_type(Type* key_type, Type* val_type, Location location)
2219     : Type(TYPE_MAP),
2220       key_type_(key_type), val_type_(val_type), location_(location)
2221   { }
2222
2223   // Return the key type.
2224   Type*
2225   key_type() const
2226   { return this->key_type_; }
2227
2228   // Return the value type.
2229   Type*
2230   val_type() const
2231   { return this->val_type_; }
2232
2233   // Whether this type is identical with T.
2234   bool
2235   is_identical(const Map_type* t, bool errors_are_identical) const;
2236
2237   // Import a map type.
2238   static Map_type*
2239   do_import(Import*);
2240
2241   static Type*
2242   make_map_type_descriptor_type();
2243
2244   static Type*
2245   make_map_descriptor_type();
2246
2247   // Build a map descriptor for this type.  Return a pointer to it.
2248   // The location is the location which causes us to need the
2249   // descriptor.
2250   tree
2251   map_descriptor_pointer(Gogo* gogo, Location);
2252
2253  protected:
2254   int
2255   do_traverse(Traverse*);
2256
2257   bool
2258   do_verify();
2259
2260   bool
2261   do_has_pointer() const
2262   { return true; }
2263
2264   bool
2265   do_compare_is_identity() const
2266   { return false; }
2267
2268   unsigned int
2269   do_hash_for_method(Gogo*) const;
2270
2271   Btype*
2272   do_get_backend(Gogo*);
2273
2274   Expression*
2275   do_type_descriptor(Gogo*, Named_type*);
2276
2277   void
2278   do_reflection(Gogo*, std::string*) const;
2279
2280   void
2281   do_mangled_name(Gogo*, std::string*) const;
2282
2283   void
2284   do_export(Export*) const;
2285
2286  private:
2287   // Mapping from map types to map descriptors.
2288   typedef Unordered_map_hash(const Map_type*, Bvariable*, Type_hash_identical,
2289                              Type_identical) Map_descriptors;
2290   static Map_descriptors map_descriptors;
2291
2292   Bvariable*
2293   map_descriptor(Gogo*);
2294
2295   // The key type.
2296   Type* key_type_;
2297   // The value type.
2298   Type* val_type_;
2299   // Where the type was defined.
2300   Location location_;
2301 };
2302
2303 // The type of a channel.
2304
2305 class Channel_type : public Type
2306 {
2307  public:
2308   Channel_type(bool may_send, bool may_receive, Type* element_type)
2309     : Type(TYPE_CHANNEL),
2310       may_send_(may_send), may_receive_(may_receive),
2311       element_type_(element_type)
2312   { go_assert(may_send || may_receive); }
2313
2314   // Whether this channel can send data.
2315   bool
2316   may_send() const
2317   { return this->may_send_; }
2318
2319   // Whether this channel can receive data.
2320   bool
2321   may_receive() const
2322   { return this->may_receive_; }
2323
2324   // The type of the values that may be sent on this channel.  This is
2325   // NULL if any type may be sent.
2326   Type*
2327   element_type() const
2328   { return this->element_type_; }
2329
2330   // Whether this type is identical with T.
2331   bool
2332   is_identical(const Channel_type* t, bool errors_are_identical) const;
2333
2334   // Import a channel type.
2335   static Channel_type*
2336   do_import(Import*);
2337
2338   static Type*
2339   make_chan_type_descriptor_type();
2340
2341  protected:
2342   int
2343   do_traverse(Traverse* traverse)
2344   { return Type::traverse(this->element_type_, traverse); }
2345
2346   bool
2347   do_has_pointer() const
2348   { return true; }
2349
2350   bool
2351   do_compare_is_identity() const
2352   { return true; }
2353
2354   unsigned int
2355   do_hash_for_method(Gogo*) const;
2356
2357   Btype*
2358   do_get_backend(Gogo*);
2359
2360   Expression*
2361   do_type_descriptor(Gogo*, Named_type*);
2362
2363   void
2364   do_reflection(Gogo*, std::string*) const;
2365
2366   void
2367   do_mangled_name(Gogo*, std::string*) const;
2368
2369   void
2370   do_export(Export*) const;
2371
2372  private:
2373   // Whether this channel can send data.
2374   bool may_send_;
2375   // Whether this channel can receive data.
2376   bool may_receive_;
2377   // The types of elements which may be sent on this channel.  If this
2378   // is NULL, it means that any type may be sent.
2379   Type* element_type_;
2380 };
2381
2382 // An interface type.
2383
2384 class Interface_type : public Type
2385 {
2386  public:
2387   Interface_type(Typed_identifier_list* methods, Location location)
2388     : Type(TYPE_INTERFACE),
2389       methods_(methods), location_(location)
2390   { go_assert(methods == NULL || !methods->empty()); }
2391
2392   // The location where the interface type was defined.
2393   Location
2394   location() const
2395   { return this->location_; }
2396
2397   // Return whether this is an empty interface.
2398   bool
2399   is_empty() const
2400   { return this->methods_ == NULL; }
2401
2402   // Return the list of methods.  This will return NULL for an empty
2403   // interface.
2404   const Typed_identifier_list*
2405   methods() const
2406   { return this->methods_; }
2407
2408   // Return the number of methods.
2409   size_t
2410   method_count() const
2411   { return this->methods_ == NULL ? 0 : this->methods_->size(); }
2412
2413   // Return the method NAME, or NULL.
2414   const Typed_identifier*
2415   find_method(const std::string& name) const;
2416
2417   // Return the zero-based index of method NAME.
2418   size_t
2419   method_index(const std::string& name) const;
2420
2421   // Finalize the methods.  This handles interface inheritance.
2422   void
2423   finalize_methods();
2424
2425   // Return true if T implements this interface.  If this returns
2426   // false, and REASON is not NULL, it sets *REASON to the reason that
2427   // it fails.
2428   bool
2429   implements_interface(const Type* t, std::string* reason) const;
2430
2431   // Whether this type is identical with T.  REASON is as in
2432   // implements_interface.
2433   bool
2434   is_identical(const Interface_type* t, bool errors_are_identical) const;
2435
2436   // Whether we can assign T to this type.  is_identical is known to
2437   // be false.
2438   bool
2439   is_compatible_for_assign(const Interface_type*, std::string* reason) const;
2440
2441   // Return whether NAME is a method which is not exported.  This is
2442   // only used for better error reporting.
2443   bool
2444   is_unexported_method(Gogo*, const std::string& name) const;
2445
2446   // Import an interface type.
2447   static Interface_type*
2448   do_import(Import*);
2449
2450   // Make a struct for an empty interface type.
2451   static Btype*
2452   get_backend_empty_interface_type(Gogo*);
2453
2454   static Type*
2455   make_interface_type_descriptor_type();
2456
2457  protected:
2458   int
2459   do_traverse(Traverse*);
2460
2461   bool
2462   do_has_pointer() const
2463   { return true; }
2464
2465   bool
2466   do_compare_is_identity() const
2467   { return false; }
2468
2469   unsigned int
2470   do_hash_for_method(Gogo*) const;
2471
2472   Btype*
2473   do_get_backend(Gogo*);
2474
2475   Expression*
2476   do_type_descriptor(Gogo*, Named_type*);
2477
2478   void
2479   do_reflection(Gogo*, std::string*) const;
2480
2481   void
2482   do_mangled_name(Gogo*, std::string*) const;
2483
2484   void
2485   do_export(Export*) const;
2486
2487  private:
2488   // The list of methods associated with the interface.  This will be
2489   // NULL for the empty interface.
2490   Typed_identifier_list* methods_;
2491   // The location where the interface was defined.
2492   Location location_;
2493 };
2494
2495 // The value we keep for a named type.  This lets us get the right
2496 // name when we convert to trees.  Note that we don't actually keep
2497 // the name here; the name is in the Named_object which points to
2498 // this.  This object exists to hold a unique tree which represents
2499 // the type.
2500
2501 class Named_type : public Type
2502 {
2503  public:
2504   Named_type(Named_object* named_object, Type* type, Location location)
2505     : Type(TYPE_NAMED),
2506       named_object_(named_object), in_function_(NULL), type_(type),
2507       local_methods_(NULL), all_methods_(NULL),
2508       interface_method_tables_(NULL), pointer_interface_method_tables_(NULL),
2509       location_(location), named_btype_(NULL), dependencies_(),
2510       is_visible_(true), is_error_(false), is_converted_(false),
2511       is_circular_(false), seen_(false), seen_in_get_backend_(false)
2512   { }
2513
2514   // Return the associated Named_object.  This holds the actual name.
2515   Named_object*
2516   named_object()
2517   { return this->named_object_; }
2518
2519   const Named_object*
2520   named_object() const
2521   { return this->named_object_; }
2522
2523   // Set the Named_object.  This is used when we see a type
2524   // declaration followed by a type.
2525   void
2526   set_named_object(Named_object* no)
2527   { this->named_object_ = no; }
2528
2529   // Return the function in which this type is defined.  This will
2530   // return NULL for a type defined in global scope.
2531   const Named_object*
2532   in_function() const
2533   { return this->in_function_; }
2534
2535   // Set the function in which this type is defined.
2536   void
2537   set_in_function(Named_object* f)
2538   { this->in_function_ = f; }
2539
2540   // Return the name of the type.
2541   const std::string&
2542   name() const;
2543
2544   // Return the name of the type for an error message.  The difference
2545   // is that if the type is defined in a different package, this will
2546   // return PACKAGE.NAME.
2547   std::string
2548   message_name() const;
2549
2550   // Return the underlying type.
2551   Type*
2552   real_type()
2553   { return this->type_; }
2554
2555   const Type*
2556   real_type() const
2557   { return this->type_; }
2558
2559   // Return the location.
2560   Location
2561   location() const
2562   { return this->location_; }
2563
2564   // Whether this type is visible.  This only matters when parsing.
2565   bool
2566   is_visible() const
2567   { return this->is_visible_; }
2568
2569   // Mark this type as visible.
2570   void
2571   set_is_visible()
2572   { this->is_visible_ = true; }
2573
2574   // Mark this type as invisible.
2575   void
2576   clear_is_visible()
2577   { this->is_visible_ = false; }
2578
2579   // Whether this is a builtin type.
2580   bool
2581   is_builtin() const
2582   { return Linemap::is_predeclared_location(this->location_); }
2583
2584   // Whether this is a circular type: a pointer or function type that
2585   // refers to itself, which is not possible in C.
2586   bool
2587   is_circular() const
2588   { return this->is_circular_; }
2589
2590   // Return the base type for this type.
2591   Type*
2592   named_base();
2593
2594   const Type*
2595   named_base() const;
2596
2597   // Return whether this is an error type.
2598   bool
2599   is_named_error_type() const;
2600
2601   // Return whether this type is comparable.  If REASON is not NULL,
2602   // set *REASON when returning false.
2603   bool
2604   named_type_is_comparable(std::string* reason) const;
2605
2606   // Add a method to this type.
2607   Named_object*
2608   add_method(const std::string& name, Function*);
2609
2610   // Add a method declaration to this type.
2611   Named_object*
2612   add_method_declaration(const std::string& name, Package* package,
2613                          Function_type* type, Location location);
2614
2615   // Add an existing method--one defined before the type itself was
2616   // defined--to a type.
2617   void
2618   add_existing_method(Named_object*);
2619
2620   // Look up a local method.
2621   Named_object*
2622   find_local_method(const std::string& name) const;
2623
2624   // Return the list of local methods.
2625   const Bindings*
2626   local_methods() const
2627   { return this->local_methods_; }
2628
2629   // Build the complete list of methods, including those from
2630   // anonymous fields, and build method stubs if needed.
2631   void
2632   finalize_methods(Gogo*);
2633
2634   // Return whether this type has any methods.  This should only be
2635   // called after the finalize_methods pass.
2636   bool
2637   has_any_methods() const
2638   { return this->all_methods_ != NULL; }
2639
2640   // Return the methods for this type.  This should only be called
2641   // after the finalized_methods pass.
2642   const Methods*
2643   methods() const
2644   { return this->all_methods_; }
2645
2646   // Return the method to use for NAME.  This returns NULL if there is
2647   // no such method or if the method is ambiguous.  When it returns
2648   // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2649   Method*
2650   method_function(const std::string& name, bool *is_ambiguous) const;
2651
2652   // Return whether NAME is a known field or method which is not
2653   // exported.  This is only used for better error reporting.
2654   bool
2655   is_unexported_local_method(Gogo*, const std::string& name) const;
2656
2657   // Return a pointer to the interface method table for this type for
2658   // the interface INTERFACE.  If IS_POINTER is true, set the type
2659   // descriptor to a pointer to this type, otherwise set it to this
2660   // type.
2661   tree
2662   interface_method_table(Gogo*, const Interface_type* interface,
2663                          bool is_pointer);
2664
2665   // Whether this type has any hidden fields.
2666   bool
2667   named_type_has_hidden_fields(std::string* reason) const;
2668
2669   // Note that a type must be converted to the backend representation
2670   // before we convert this type.
2671   void
2672   add_dependency(Named_type* nt)
2673   { this->dependencies_.push_back(nt); }
2674
2675   // Export the type.
2676   void
2677   export_named_type(Export*, const std::string& name) const;
2678
2679   // Import a named type.
2680   static void
2681   import_named_type(Import*, Named_type**);
2682
2683   // Initial conversion to backend representation.
2684   void
2685   convert(Gogo*);
2686
2687  protected:
2688   int
2689   do_traverse(Traverse* traverse)
2690   { return Type::traverse(this->type_, traverse); }
2691
2692   bool
2693   do_verify();
2694
2695   bool
2696   do_has_pointer() const;
2697
2698   bool
2699   do_compare_is_identity() const;
2700
2701   unsigned int
2702   do_hash_for_method(Gogo*) const;
2703
2704   Btype*
2705   do_get_backend(Gogo*);
2706
2707   Expression*
2708   do_type_descriptor(Gogo*, Named_type*);
2709
2710   void
2711   do_reflection(Gogo*, std::string*) const;
2712
2713   void
2714   do_mangled_name(Gogo*, std::string* ret) const;
2715
2716   void
2717   do_export(Export*) const;
2718
2719  private:
2720   // Create the placeholder during conversion.
2721   void
2722   create_placeholder(Gogo*);
2723
2724   // A mapping from interfaces to the associated interface method
2725   // tables for this type.  This maps to a decl.
2726   typedef Unordered_map_hash(const Interface_type*, tree, Type_hash_identical,
2727                              Type_identical) Interface_method_tables;
2728
2729   // A pointer back to the Named_object for this type.
2730   Named_object* named_object_;
2731   // If this type is defined in a function, a pointer back to the
2732   // function in which it is defined.
2733   Named_object* in_function_;
2734   // The actual type.
2735   Type* type_;
2736   // The list of methods defined for this type.  Any named type can
2737   // have methods.
2738   Bindings* local_methods_;
2739   // The full list of methods for this type, including methods
2740   // declared for anonymous fields.
2741   Methods* all_methods_;
2742   // A mapping from interfaces to the associated interface method
2743   // tables for this type.
2744   Interface_method_tables* interface_method_tables_;
2745   // A mapping from interfaces to the associated interface method
2746   // tables for pointers to this type.
2747   Interface_method_tables* pointer_interface_method_tables_;
2748   // The location where this type was defined.
2749   Location location_;
2750   // The backend representation of this type during backend
2751   // conversion.  This is used to avoid endless recursion when a named
2752   // type refers to itself.
2753   Btype* named_btype_;
2754   // A list of types which must be converted to the backend
2755   // representation before this type can be converted.  This is for
2756   // cases like
2757   //   type S1 { p *S2 }
2758   //   type S2 { s S1 }
2759   // where we can't convert S2 to the backend representation unless we
2760   // have converted S1.
2761   std::vector<Named_type*> dependencies_;
2762   // Whether this type is visible.  This is false if this type was
2763   // created because it was referenced by an imported object, but the
2764   // type itself was not exported.  This will always be true for types
2765   // created in the current package.
2766   bool is_visible_;
2767   // Whether this type is erroneous.
2768   bool is_error_;
2769   // Whether this type has been converted to the backend
2770   // representation.
2771   bool is_converted_;
2772   // Whether this is a pointer or function type which refers to the
2773   // type itself.
2774   bool is_circular_;
2775   // In a recursive operation such as has_hidden_fields, this flag is
2776   // used to prevent infinite recursion when a type refers to itself.
2777   // This is mutable because it is always reset to false when the
2778   // function exits.
2779   mutable bool seen_;
2780   // Like seen_, but used only by do_get_backend.
2781   bool seen_in_get_backend_;
2782 };
2783
2784 // A forward declaration.  This handles a type which has been declared
2785 // but not defined.
2786
2787 class Forward_declaration_type : public Type
2788 {
2789  public:
2790   Forward_declaration_type(Named_object* named_object);
2791
2792   // The named object associated with this type declaration.  This
2793   // will be resolved.
2794   Named_object*
2795   named_object();
2796
2797   const Named_object*
2798   named_object() const;
2799
2800   // Return the name of the type.
2801   const std::string&
2802   name() const;
2803
2804   // Return the type to which this points.  Give an error if the type
2805   // has not yet been defined.
2806   Type*
2807   real_type();
2808
2809   const Type*
2810   real_type() const;
2811
2812   // Whether the base type has been defined.
2813   bool
2814   is_defined() const;
2815
2816   // Add a method to this type.
2817   Named_object*
2818   add_method(const std::string& name, Function*);
2819
2820   // Add a method declaration to this type.
2821   Named_object*
2822   add_method_declaration(const std::string& name, Function_type*,
2823                          Location);
2824
2825  protected:
2826   int
2827   do_traverse(Traverse* traverse);
2828
2829   bool
2830   do_has_pointer() const
2831   { return this->real_type()->has_pointer(); }
2832
2833   bool
2834   do_compare_is_identity() const
2835   { return this->real_type()->compare_is_identity(); }
2836
2837   unsigned int
2838   do_hash_for_method(Gogo* gogo) const
2839   { return this->real_type()->hash_for_method(gogo); }
2840
2841   Btype*
2842   do_get_backend(Gogo* gogo);
2843
2844   Expression*
2845   do_type_descriptor(Gogo*, Named_type*);
2846
2847   void
2848   do_reflection(Gogo*, std::string*) const;
2849
2850   void
2851   do_mangled_name(Gogo*, std::string* ret) const;
2852
2853   void
2854   do_export(Export*) const;
2855
2856  private:
2857   // Issue a warning about a use of an undefined type.
2858   void
2859   warn() const;
2860
2861   // The type declaration.
2862   Named_object* named_object_;
2863   // Whether we have issued a warning about this type.
2864   mutable bool warned_;
2865 };
2866
2867 // The Type_context struct describes what we expect for the type of an
2868 // expression.
2869
2870 struct Type_context
2871 {
2872   // The exact type we expect, if known.  This may be NULL.
2873   Type* type;
2874   // Whether an abstract type is permitted.
2875   bool may_be_abstract;
2876
2877   // Constructors.
2878   Type_context()
2879     : type(NULL), may_be_abstract(false)
2880   { }
2881
2882   Type_context(Type* a_type, bool a_may_be_abstract)
2883     : type(a_type), may_be_abstract(a_may_be_abstract)
2884   { }
2885 };
2886
2887 #endif // !defined(GO_TYPES_H)