OSDN Git Service

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