go/gofrontend/types.cc

106 // If this is a named type, return it.  Otherwise, return NULL.
232 // If this is a pointer type, return the type to which it points.
423 // Return true if it's OK to have a binary operation with types LHS
678   // it is representable in that type.
922       // don't want to record that for a forwarding type, as it may
941 // it points.  This is used while converting all named types to the
1241       // it.
1247       // any package where it is needed, and the linker will pick one
1276 // NULL, use it to get the name.  Otherwise this is an unnamed type.
1336 // package.  If this returns true it sets *PACKAGE to the package.
1453 // runtime.Type rather than copying it.  This must match commonType in
1472       // require us to create the unsafe package if it has not been
1551 // this type are equal.  If NAME is not NULL it is the name of this
1736       // type, but otherwise it will confuse the code that builds
2148       // it.
2154       // any package where it is needed, and the linker will pick one
2186   // Type::gc_symbol to allow it to add extra information as is necessary.
2222 // struct.  If name is not NULL, it is the name of the type.  If
2223 // METHODS is not NULL, it is the list of methods.  ONLY_VALUE_METHODS
2439 // NULL, it is the name to use as well as the list of methods.
2471   // mangled name.  For a composite type it should append a code for
3227       // backend representation, so force it to be finished now.
3329 // type may be assigned to it.
3394 // brief explanation of why it returned false.
3763   // When we do anything with a function value other than call it, it
4428 // The nil type.  We use a special type for nil because it is not the
4650   // We know that a field is an embedded type if it is anonymous.
4651   // We can decide if it is a built-in type by checking to see if it is
4884 // Return an expression for a field, along with the depth at which it
4939 		  // If this is an error, it will be reported
4987 	  // We do not handle ambiguity here--it should be handled by
5064 // Return the method NAME, or NULL if there isn't one or if it is
6083 // simply represented as ARRAY_TYPE with the appropriate index--i.e., it is
6116 // computed using a function call, so we must only evaluate it once.
6698 // Build a map descriptor for this type.  Return a pointer to it.
7172       Interface_type* it = t->interface_type();
7173       if (it == NULL)
7179       if (it == this)
7190       if (nt != NULL && it->parse_methods_ != NULL)
7206       const Typed_identifier_list* imethods = it->parse_methods_;
7428 // Return true if T implements the interface.  If it does not, and
7441   // If we start with a named type, we don't dereference it to find
7449 	  // the type to which it points.
7456   // If we have a named type, get the methods from it rather than from
8253   // If this is not a local method, and it does not use a stub, then
8289 // Insert a new method.  Return true if it was inserted, false
8510 // Return the method NAME, or NULL if there isn't one or if it is
8765   // not have verified the type yet.  We have to make sure it is
9050       // it.
9067       // it.
9103   // underlying type, giving it the name NAME.
9122       // When -fgo-pkgpath or -fgo-prefix is specified, we use it to
9126       // package path, so that the reflect methods can discard it.
9231   // We don't need to write the name of the type here, because it will
9250 // Export the type when it is referenced by another type.  In this
9411   // Look for anonymous fields in TYPE.  TYPE has fields if it is a
9439 	  // This is an error, but it will be diagnosed elsewhere.
9489   const Interface_type* it = type->interface_type();
9490   if (it == NULL)
9493   const Typed_identifier_list* imethods = it->methods();
9504 	  // This is an error, but it should be reported elsewhere
9713 // or NULL if there isn't one or if it is ambiguous.  If IS_AMBIGUOUS
9783   const Interface_type* it = type->interface_type();
9785   // If this is a pointer to a pointer, then it is possible that the
9790       && it == NULL
9827       else if (it != NULL && it->find_method(name) != NULL)
9866       else if (nt == NULL && st == NULL && it == NULL)
9900 // otherwise, if a field is found, set it to false.  If
9906 // method we couldn't use because it requires a pointer.  LEVEL is
9908 // When this function returns false because it finds that the name is
9909 // ambiguous, it will store a path to the ambiguous names in *AMBIG1
9914 // method, and whether it is a field or method.  It doesn't build an
9915 // expression to refer to it.  If it is a method, we then look in the
9916 // list of all methods for the type.  If it is a field, the search has
9965   const Interface_type* it = type->interface_type();
9966   if (it != NULL && it->find_method(name) != NULL)
10052 	  // if we want to use this one, or whether it introduces an
10094       // type, it is invalid to automatically dereference the pointer to the
10146   const Interface_type* it = type->interface_type();
10147   if (it != NULL && it->is_unexported_method(gogo, name))
10179 	      // This is an error, but it will be diagnosed elsewhere.