OSDN Git Service

2007-08-31 Hristian Kirtchev <kirtchev@adacore.com>
[pf3gnuchains/gcc-fork.git] / 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-2007, 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 2,  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 COPYING.  If not, write --
19 -- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
20 -- Boston, MA 02110-1301, USA.                                              --
21 --                                                                          --
22 -- GNAT was originally developed  by the GNAT team at  New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
24 --                                                                          --
25 ------------------------------------------------------------------------------
26
27 --  This unit contains the routines used to handle type determination,
28 --  including the routine used to support overload resolution.
29
30 with Types; use Types;
31
32 package Sem_Type is
33
34    ---------------------------------------------
35    -- Data Structures for Overload Resolution --
36    ---------------------------------------------
37
38    --  To determine the unique meaning of an identifier, overload resolution
39    --  may have to be performed if the visibility rules alone identify more
40    --  than one possible entity as the denotation of a given identifier. When
41    --  the visibility rules find such a potential ambiguity, the set of
42    --  possible interpretations must be attached to the identifier, and
43    --  overload resolution must be performed over the innermost enclosing
44    --  complete context. At the end of the resolution, either a single
45    --  interpretation is found for all identifiers in the context, or else a
46    --  type error (invalid type or ambiguous reference) must be signalled.
47
48    --  The set of interpretations of a given name is stored in a data structure
49    --  that is separate from the syntax tree, because it corresponds to
50    --  transient information. The interpretations themselves are stored in
51    --  table All_Interp. A mapping from tree nodes to sets of interpretations
52    --  called Interp_Map, is maintained by the overload resolution routines.
53    --  Both these structures are initialized at the beginning of every complete
54    --  context.
55
56    --  Corresponding to the set of interpretations for a given overloadable
57    --  identifier, there is a set of possible types corresponding to the types
58    --  that the overloaded call may return. We keep a 1-to-1 correspondence
59    --  between interpretations and types: for user-defined subprograms the
60    --  type is the declared return type. For operators, the type is determined
61    --  by the type of the arguments. If the arguments themselves are
62    --  overloaded, we enter the operator name in the names table for each
63    --  possible result type. In most cases, arguments are not overloaded and
64    --  only one interpretation is present anyway.
65
66    type Interp is record
67       Nam         : Entity_Id;
68       Typ         : Entity_Id;
69       Abstract_Op : Entity_Id := Empty;
70    end record;
71
72    --  Entity Abstract_Op is set to the abstract operation which potentially
73    --  disables the interpretation in Ada 2005 mode.
74
75    No_Interp : constant Interp := (Empty, Empty, Empty);
76
77    subtype Interp_Index is Int;
78
79    ---------------------
80    -- Error Reporting --
81    ---------------------
82
83    --  A common error is the use of an operator in infix notation on arguments
84    --  of a type that is not directly visible. Rather than diagnosing a type
85    --  mismatch, it is better to indicate that the type can be made use-visible
86    --  with the appropriate use clause. The global variable Candidate_Type is
87    --  set in Add_One_Interp whenever an interpretation might be legal for an
88    --  operator if the type were directly visible. This variable is used in
89    --  sem_ch4 when no legal interpretation is found.
90
91    Candidate_Type : Entity_Id;
92
93    -----------------
94    -- Subprograms --
95    -----------------
96
97    procedure Init_Interp_Tables;
98    --  Invoked by gnatf when processing multiple files
99
100    procedure Collect_Interps (N : Node_Id);
101    --  Invoked when the name N has more than one visible interpretation.
102    --  This is the high level routine which accumulates the possible
103    --  interpretations of the node. The first meaning and type of N have
104    --  already been stored in N. If the name is an expanded name, the homonyms
105    --  are only those that belong to the same scope.
106
107    function Is_Invisible_Operator
108      (N    : Node_Id;
109       T    : Entity_Id)
110       return Boolean;
111    --  Check whether a predefined operation with universal operands appears
112    --  in a context in which the operators of the expected type are not
113    --  visible.
114
115    procedure List_Interps (Nam : Node_Id; Err : Node_Id);
116    --  List candidate interpretations of an overloaded name. Used for
117    --  various error reports.
118
119    procedure Add_One_Interp
120      (N         : Node_Id;
121       E         : Entity_Id;
122       T         : Entity_Id;
123       Opnd_Type : Entity_Id := Empty);
124    --  Add (E, T) to the list of interpretations of the node being resolved.
125    --  For calls and operators, i.e. for nodes that have a name field,
126    --  E is an overloadable entity, and T is its type. For constructs such
127    --  as indexed expressions, the caller sets E equal to T, because the
128    --  overloading comes from other fields, and the node itself has no name
129    --  to resolve. Hidden denotes whether an interpretation has been disabled
130    --  by an abstract operator. Add_One_Interp includes semantic processing to
131    --  deal with adding entries that hide one another etc.
132
133    --  For operators, the legality of the operation depends on the visibility
134    --  of T and its scope. If the operator is an equality or comparison, T is
135    --  always Boolean, and we use Opnd_Type, which is a candidate type for one
136    --  of the operands of N, to check visibility.
137
138    procedure End_Interp_List;
139    --  End the list of interpretations of current node
140
141    procedure Get_First_Interp
142      (N  : Node_Id;
143       I  : out Interp_Index;
144       It : out Interp);
145    --  Initialize iteration over set of interpretations for Node N. The first
146    --  interpretation is placed in It, and I is initialized for subsequent
147    --  calls to Get_Next_Interp.
148
149    procedure Get_Next_Interp (I : in out Interp_Index; It : out Interp);
150    --  Iteration step over set of interpretations. Using the value in I, which
151    --  was set by a previous call to Get_First_Interp or Get_Next_Interp, the
152    --  next interpretation is placed in It, and I is updated for the next call.
153    --  The end of the list of interpretations is signalled by It.Nam = Empty.
154
155    procedure Remove_Interp (I : in out Interp_Index);
156    --  Remove an interpretation that his hidden by another, or that does not
157    --  match the context. The value of I on input was set by a call to either
158    --  Get_First_Interp or Get_Next_Interp and references the interpretation
159    --  to be removed. The only allowed use of the exit value of I is as input
160    --  to a subsequent call to Get_Next_Interp, which yields the interpretation
161    --  following the removed one.
162
163    procedure Save_Interps (Old_N : Node_Id; New_N : Node_Id);
164    --  If an overloaded node is rewritten during semantic analysis, its
165    --  possible interpretations must be linked to the copy. This procedure
166    --  transfers the overload information from Old_N, the old node, to
167    --  New_N, its new copy. It has no effect in the non-overloaded case.
168
169    function Covers (T1, T2 : Entity_Id) return Boolean;
170    --  This is the basic type compatibility routine. T1 is the expected
171    --  type, imposed by context, and T2 is the actual type. The processing
172    --  reflects both the definition of type coverage and the rules
173    --  for operand matching.
174
175    function Disambiguate
176      (N      : Node_Id;
177       I1, I2 : Interp_Index;
178       Typ    : Entity_Id)
179       return   Interp;
180    --  If more than one interpretation of a name in a call is legal, apply
181    --  preference rules (universal types first) and operator visibility in
182    --  order to remove ambiguity. I1 and I2 are the first two interpretations
183    --  that are compatible with the context, but there may be others.
184
185    function Entity_Matches_Spec (Old_S,  New_S : Entity_Id) return Boolean;
186    --  To resolve subprogram renaming and default formal subprograms in generic
187    --  definitions. Old_S is a possible interpretation of the entity being
188    --  renamed, New_S has an explicit signature. If Old_S is a subprogram, as
189    --  opposed to an operator, type and mode conformance are required.
190
191    function Find_Unique_Type (L : Node_Id; R : Node_Id) return Entity_Id;
192    --  Used in second pass of resolution,  for equality and comparison nodes.
193    --  L is the left operand, whose type is known to be correct, and R is
194    --  the right operand,  which has one interpretation compatible with that
195    --  of L. Return the type intersection of the two.
196
197    function Has_Compatible_Type
198      (N    : Node_Id;
199       Typ  : Entity_Id)
200       return Boolean;
201    --  Verify that some interpretation of the node N has a type compatible
202    --  with Typ. If N is not overloaded, then its unique type must be
203    --  compatible with Typ. Otherwise iterate through the interpretations
204    --  of N looking for a compatible one.
205
206    function Hides_Op (F : Entity_Id; Op : Entity_Id) return Boolean;
207    --  A user-defined function hides a predefined operator if it is
208    --  matches the signature of the operator, and is declared in an
209    --  open scope, or in the scope of the result type.
210
211    function Interface_Present_In_Ancestor
212      (Typ   : Entity_Id;
213       Iface : Entity_Id) return Boolean;
214    --  Ada 2005 (AI-251): Typ must be a tagged record type/subtype and Iface
215    --  must be an abstract interface type (or a class-wide abstract interface).
216    --  This function is used to check if Typ or some ancestor of Typ implements
217    --  Iface (returning True only if so).
218
219    function Intersect_Types (L, R : Node_Id) return Entity_Id;
220    --  Find the common interpretation to two analyzed nodes. If one of the
221    --  interpretations is universal, choose the non-universal one. If either
222    --  node is overloaded, find single common interpretation.
223
224    function Is_Ancestor (T1, T2 : Entity_Id) return Boolean;
225    --  T1 is a tagged type (not class-wide). Verify that it is one of the
226    --  ancestors of type T2 (which may or not be class-wide)
227
228    function Is_Subtype_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean;
229    --  Checks whether T1 is any subtype of T2 directly or indirectly. Applies
230    --  only to scalar subtypes ???
231
232    function Operator_Matches_Spec (Op, New_S : Entity_Id) return Boolean;
233    --  Used to resolve subprograms renaming operators, and calls to user
234    --  defined operators. Determines whether a given operator Op, matches
235    --  a specification, New_S.
236
237    procedure Set_Abstract_Op (I : Interp_Index; V : Entity_Id);
238    --  Set the abstract operation field of an interpretation
239
240    function Valid_Comparison_Arg (T : Entity_Id) return Boolean;
241    --  A valid argument to an ordering operator must be a discrete type, a
242    --  real type, or a one dimensional array with a discrete component type.
243
244    function Valid_Boolean_Arg (T : Entity_Id) return Boolean;
245    --  A valid argument of a boolean operator is either some boolean type,
246    --  or a one-dimensional array of boolean type.
247
248    procedure Write_Interp_Ref (Map_Ptr : Int);
249    --  Debugging procedure to display entry in Interp_Map. Would not be
250    --  needed if it were possible to debug instantiations of Table.
251
252    procedure Write_Overloads (N : Node_Id);
253    --  Debugging procedure to output info on possibly overloaded entities
254    --  for specified node.
255
256 end Sem_Type;