gcc/ada/sem_type.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                             S E M _ T Y P E                              --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2018, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 --  This unit contains the routines used to handle type determination,
  27 --  including the routine used to support overload resolution.
  28
  29 with Types; use Types;
  30
  31 package Sem_Type is
  32
  33    ---------------------------------------------
  34    -- Data Structures for Overload Resolution --
  35    ---------------------------------------------
  36
  37    --  To determine the unique meaning of an identifier, overload resolution
  38    --  may have to be performed if the visibility rules alone identify more
  39    --  than one possible entity as the denotation of a given identifier. When
  40    --  the visibility rules find such a potential ambiguity, the set of
  41    --  possible interpretations must be attached to the identifier, and
  42    --  overload resolution must be performed over the innermost enclosing
  43    --  complete context. At the end of the resolution, either a single
  44    --  interpretation is found for all identifiers in the context, or else a
  45    --  type error (invalid type or ambiguous reference) must be signalled.
  46
  47    --  The set of interpretations of a given name is stored in a data structure
  48    --  that is separate from the syntax tree, because it corresponds to
  49    --  transient information. The interpretations themselves are stored in
  50    --  table All_Interp. A mapping from tree nodes to sets of interpretations
  51    --  called Interp_Map, is maintained by the overload resolution routines.
  52    --  Both these structures are initialized at the beginning of every complete
  53    --  context.
  54
  55    --  Corresponding to the set of interpretations for a given overloadable
  56    --  identifier, there is a set of possible types corresponding to the types
  57    --  that the overloaded call may return. We keep a 1-to-1 correspondence
  58    --  between interpretations and types: for user-defined subprograms the type
  59    --  is the declared return type. For operators, the type is determined by
  60    --  the type of the arguments. If the arguments themselves are overloaded,
  61    --  we enter the operator name in the names table for each possible result
  62    --  type. In most cases, arguments are not overloaded and only one
  63    --  interpretation is present anyway.
  64
  65    type Interp is record
  66       Nam         : Entity_Id;
  67       Typ         : Entity_Id;
  68       Abstract_Op : Entity_Id := Empty;
  69    end record;
  70
  71    --  Entity Abstract_Op is set to the abstract operation which potentially
  72    --  disables the interpretation in Ada 2005 mode.
  73
  74    No_Interp : constant Interp := (Empty, Empty, Empty);
  75
  76    type Interp_Index is new Int;
  77
  78    ---------------------
  79    -- Error Reporting --
  80    ---------------------
  81
  82    --  A common error is the use of an operator in infix notation on arguments
  83    --  of a type that is not directly visible. Rather than diagnosing a type
  84    --  mismatch, it is better to indicate that the type can be made use-visible
  85    --  with the appropriate use clause. The global variable Candidate_Type is
  86    --  set in Add_One_Interp whenever an interpretation might be legal for an
  87    --  operator if the type were directly visible. This variable is used in
  88    --  sem_ch4 when no legal interpretation is found.
  89
  90    Candidate_Type : Entity_Id;
  91
  92    -----------------
  93    -- Subprograms --
  94    -----------------
  95
  96    procedure Init_Interp_Tables;
  97    --  Invoked by gnatf when processing multiple files
  98
  99    procedure Collect_Interps (N : Node_Id);
 100    --  Invoked when the name N has more than one visible interpretation. This
 101    --  is the high level routine which accumulates the possible interpretations
 102    --  of the node. The first meaning and type of N have already been stored
 103    --  in N. If the name is an expanded name, the homonyms are only those that
 104    --  belong to the same scope.
 105
 106    function Is_Invisible_Operator (N : Node_Id; T : Entity_Id) return Boolean;
 107    --  Check whether a predefined operation with universal operands appears in
 108    --  a context in which the operators of the expected type are not visible.
 109
 110    procedure List_Interps (Nam : Node_Id; Err : Node_Id);
 111    --  List candidate interpretations of an overloaded name. Used for various
 112    --  error reports.
 113
 114    procedure Add_One_Interp
 115      (N         : Node_Id;
 116       E         : Entity_Id;
 117       T         : Entity_Id;
 118       Opnd_Type : Entity_Id := Empty);
 119    --  Add (E, T) to the list of interpretations of the node being resolved.
 120    --  For calls and operators, i.e. for nodes that have a name field, E is an
 121    --  overloadable entity, and T is its type. For constructs such as indexed
 122    --  expressions, the caller sets E equal to T, because the overloading comes
 123    --  from other fields, and the node itself has no name to resolve. Hidden
 124    --  denotes whether an interpretation has been disabled by an abstract
 125    --  operator. Add_One_Interp includes semantic processing to deal with
 126    --  adding entries that hide one another etc.
 127    --
 128    --  For operators, the legality of the operation depends on the visibility
 129    --  of T and its scope. If the operator is an equality or comparison, T is
 130    --  always Boolean, and we use Opnd_Type, which is a candidate type for one
 131    --  of the operands of N, to check visibility.
 132
 133    procedure End_Interp_List;
 134    --  End the list of interpretations of current node
 135
 136    procedure Get_First_Interp
 137      (N  : Node_Id;
 138       I  : out Interp_Index;
 139       It : out Interp);
 140    --  Initialize iteration over set of interpretations for Node N. The first
 141    --  interpretation is placed in It, and I is initialized for subsequent
 142    --  calls to Get_Next_Interp.
 143
 144    procedure Get_Next_Interp (I : in out Interp_Index; It : out Interp);
 145    --  Iteration step over set of interpretations. Using the value in I, which
 146    --  was set by a previous call to Get_First_Interp or Get_Next_Interp, the
 147    --  next interpretation is placed in It, and I is updated for the next call.
 148    --  The end of the list of interpretations is signalled by It.Nam = Empty.
 149
 150    procedure Remove_Interp (I : in out Interp_Index);
 151    --  Remove an interpretation that is hidden by another, or that does not
 152    --  match the context. The value of I on input was set by a call to either
 153    --  Get_First_Interp or Get_Next_Interp and references the interpretation
 154    --  to be removed. The only allowed use of the exit value of I is as input
 155    --  to a subsequent call to Get_Next_Interp, which yields the interpretation
 156    --  following the removed one.
 157
 158    procedure Save_Interps (Old_N : Node_Id; New_N : Node_Id);
 159    --  If an overloaded node is rewritten during semantic analysis, its
 160    --  possible interpretations must be linked to the copy. This procedure
 161    --  transfers the overload information (Is_Overloaded flag, and list of
 162    --  interpretations) from Old_N, the old node, to New_N, its new copy.
 163    --  It has no effect in the non-overloaded case.
 164
 165    function Covers (T1, T2 : Entity_Id) return Boolean;
 166    --  This is the basic type compatibility routine. T1 is the expected type,
 167    --  imposed by context, and T2 is the actual type. The processing reflects
 168    --  both the definition of type coverage and the rules for operand matching;
 169    --  that is, this does not exactly match the RM definition of "covers".
 170
 171    function Disambiguate
 172      (N      : Node_Id;
 173       I1, I2 : Interp_Index;
 174       Typ    : Entity_Id) return Interp;
 175    --  If more than one interpretation of a name in a call is legal, apply
 176    --  preference rules (universal types first) and operator visibility in
 177    --  order to remove ambiguity. I1 and I2 are the first two interpretations
 178    --  that are compatible with the context, but there may be others.
 179
 180    function Entity_Matches_Spec (Old_S,  New_S : Entity_Id) return Boolean;
 181    --  To resolve subprogram renaming and default formal subprograms in generic
 182    --  definitions. Old_S is a possible interpretation of the entity being
 183    --  renamed, New_S has an explicit signature. If Old_S is a subprogram, as
 184    --  opposed to an operator, type and mode conformance are required.
 185
 186    function Find_Unique_Type (L : Node_Id; R : Node_Id) return Entity_Id;
 187    --  Used in second pass of resolution, for equality and comparison nodes. L
 188    --  is the left operand, whose type is known to be correct, and R is the
 189    --  right operand, which has one interpretation compatible with that of L.
 190    --  Return the type intersection of the two.
 191
 192    function Has_Compatible_Type (N : Node_Id; Typ : Entity_Id) return Boolean;
 193    --  Verify that some interpretation of the node N has a type compatible with
 194    --  Typ. If N is not overloaded, then its unique type must be compatible
 195    --  with Typ. Otherwise iterate through the interpretations of N looking for
 196    --  a compatible one.
 197
 198    function Hides_Op (F : Entity_Id; Op : Entity_Id) return Boolean;
 199    --  A user-defined function hides a predefined operator if it is matches the
 200    --  signature of the operator, and is declared in an open scope, or in the
 201    --  scope of the result type.
 202
 203    function Interface_Present_In_Ancestor
 204      (Typ   : Entity_Id;
 205       Iface : Entity_Id) return Boolean;
 206    --  Ada 2005 (AI-251): Typ must be a tagged record type/subtype and Iface
 207    --  must be an abstract interface type (or a class-wide abstract interface).
 208    --  This function is used to check if Typ or some ancestor of Typ implements
 209    --  Iface (returning True only if so).
 210
 211    function Intersect_Types (L, R : Node_Id) return Entity_Id;
 212    --  Find the common interpretation to two analyzed nodes. If one of the
 213    --  interpretations is universal, choose the non-universal one. If either
 214    --  node is overloaded, find single common interpretation.
 215
 216    function In_Generic_Actual (Exp : Node_Id) return Boolean;
 217    --  Determine whether the expression is part of a generic actual. At the
 218    --  time the actual is resolved the scope is already that of the instance,
 219    --  but conceptually the resolution of the actual takes place in the
 220    --  enclosing context and no special disambiguation rules should be applied.
 221
 222    function Is_Ancestor
 223      (T1            : Entity_Id;
 224       T2            : Entity_Id;
 225       Use_Full_View : Boolean := False) return Boolean;
 226    --  T1 is a tagged type (not class-wide). Verify that it is one of the
 227    --  ancestors of type T2 (which may or not be class-wide). If Use_Full_View
 228    --  is True then the full-view of private parents is used when climbing
 229    --  through the parents of T2.
 230    --
 231    --  Note: For analysis purposes the flag Use_Full_View must be set to False
 232    --  (otherwise we break the privacy contract since this routine returns true
 233    --  for hidden ancestors of private types). For expansion purposes this flag
 234    --  is generally set to True since the expander must know with precision the
 235    --  ancestors of a tagged type. For example, if a private type derives from
 236    --  an interface type then the interface may not be an ancestor of its full
 237    --  view since the full-view is only required to cover the interface (RM 7.3
 238    --  (7.3/2))) and this knowledge affects construction of dispatch tables.
 239
 240    function Is_Progenitor
 241      (Iface : Entity_Id;
 242       Typ   : Entity_Id) return Boolean;
 243    --  Determine whether the interface Iface is implemented by Typ. It requires
 244    --  traversing the list of abstract interfaces of the type, as well as that
 245    --  of the ancestor types. The predicate is used to determine when a formal
 246    --  in the signature of an inherited operation must carry the derived type.
 247
 248    function Is_Subtype_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean;
 249    --  Checks whether T1 is any subtype of T2 directly or indirectly. Applies
 250    --  only to scalar subtypes???
 251
 252    function Operator_Matches_Spec (Op, New_S : Entity_Id) return Boolean;
 253    --  Used to resolve subprograms renaming operators, and calls to user
 254    --  defined operators. Determines whether a given operator Op, matches
 255    --  a specification, New_S.
 256
 257    procedure Set_Abstract_Op (I : Interp_Index; V : Entity_Id);
 258    --  Set the abstract operation field of an interpretation
 259
 260    function Valid_Comparison_Arg (T : Entity_Id) return Boolean;
 261    --  A valid argument to an ordering operator must be a discrete type, a
 262    --  real type, or a one dimensional array with a discrete component type.
 263
 264    function Valid_Boolean_Arg (T : Entity_Id) return Boolean;
 265    --  A valid argument of a boolean operator is either some boolean type, or a
 266    --  one-dimensional array of boolean type.
 267
 268    procedure Write_Interp (It : Interp);
 269    --  Debugging procedure to display an Interp
 270
 271    procedure Write_Interp_Ref (Map_Ptr : Int);
 272    --  Debugging procedure to display entry in Interp_Map. Would not be needed
 273    --  if it were possible to debug instantiations of Table.
 274
 275    procedure Write_Overloads (N : Node_Id);
 276    --  Debugging procedure to output info on possibly overloaded entities for
 277    --  specified node.
 278
 279 end Sem_Type;