OSDN Git Service

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