1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
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. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Atree; use Atree;
28 with Debug; use Debug;
29 with Einfo; use Einfo;
30 with Elists; use Elists;
31 with Nlists; use Nlists;
32 with Errout; use Errout;
34 with Namet; use Namet;
36 with Output; use Output;
38 with Sem_Aux; use Sem_Aux;
39 with Sem_Ch6; use Sem_Ch6;
40 with Sem_Ch8; use Sem_Ch8;
41 with Sem_Ch12; use Sem_Ch12;
42 with Sem_Disp; use Sem_Disp;
43 with Sem_Dist; use Sem_Dist;
44 with Sem_Util; use Sem_Util;
45 with Stand; use Stand;
46 with Sinfo; use Sinfo;
47 with Snames; use Snames;
49 with Uintp; use Uintp;
51 package body Sem_Type is
57 -- The following data structures establish a mapping between nodes and
58 -- their interpretations. An overloaded node has an entry in Interp_Map,
59 -- which in turn contains a pointer into the All_Interp array. The
60 -- interpretations of a given node are contiguous in All_Interp. Each set
61 -- of interpretations is terminated with the marker No_Interp. In order to
62 -- speed up the retrieval of the interpretations of an overloaded node, the
63 -- Interp_Map table is accessed by means of a simple hashing scheme, and
64 -- the entries in Interp_Map are chained. The heads of clash lists are
65 -- stored in array Headers.
67 -- Headers Interp_Map All_Interp
69 -- _ +-----+ +--------+
70 -- |_| |_____| --->|interp1 |
71 -- |_|---------->|node | | |interp2 |
72 -- |_| |index|---------| |nointerp|
77 -- This scheme does not currently reclaim interpretations. In principle,
78 -- after a unit is compiled, all overloadings have been resolved, and the
79 -- candidate interpretations should be deleted. This should be easier
80 -- now than with the previous scheme???
82 package All_Interp is new Table.Table (
83 Table_Component_Type => Interp,
84 Table_Index_Type => Int,
86 Table_Initial => Alloc.All_Interp_Initial,
87 Table_Increment => Alloc.All_Interp_Increment,
88 Table_Name => "All_Interp");
90 type Interp_Ref is record
96 Header_Size : constant Int := 2 ** 12;
97 No_Entry : constant Int := -1;
98 Headers : array (0 .. Header_Size) of Int := (others => No_Entry);
100 package Interp_Map is new Table.Table (
101 Table_Component_Type => Interp_Ref,
102 Table_Index_Type => Int,
103 Table_Low_Bound => 0,
104 Table_Initial => Alloc.Interp_Map_Initial,
105 Table_Increment => Alloc.Interp_Map_Increment,
106 Table_Name => "Interp_Map");
108 function Hash (N : Node_Id) return Int;
109 -- A trivial hashing function for nodes, used to insert an overloaded
110 -- node into the Interp_Map table.
112 -------------------------------------
113 -- Handling of Overload Resolution --
114 -------------------------------------
116 -- Overload resolution uses two passes over the syntax tree of a complete
117 -- context. In the first, bottom-up pass, the types of actuals in calls
118 -- are used to resolve possibly overloaded subprogram and operator names.
119 -- In the second top-down pass, the type of the context (for example the
120 -- condition in a while statement) is used to resolve a possibly ambiguous
121 -- call, and the unique subprogram name in turn imposes a specific context
122 -- on each of its actuals.
124 -- Most expressions are in fact unambiguous, and the bottom-up pass is
125 -- sufficient to resolve most everything. To simplify the common case,
126 -- names and expressions carry a flag Is_Overloaded to indicate whether
127 -- they have more than one interpretation. If the flag is off, then each
128 -- name has already a unique meaning and type, and the bottom-up pass is
129 -- sufficient (and much simpler).
131 --------------------------
132 -- Operator Overloading --
133 --------------------------
135 -- The visibility of operators is handled differently from that of other
136 -- entities. We do not introduce explicit versions of primitive operators
137 -- for each type definition. As a result, there is only one entity
138 -- corresponding to predefined addition on all numeric types, etc. The
139 -- back-end resolves predefined operators according to their type. The
140 -- visibility of primitive operations then reduces to the visibility of the
141 -- resulting type: (a + b) is a legal interpretation of some primitive
142 -- operator + if the type of the result (which must also be the type of a
143 -- and b) is directly visible (either immediately visible or use-visible).
145 -- User-defined operators are treated like other functions, but the
146 -- visibility of these user-defined operations must be special-cased
147 -- to determine whether they hide or are hidden by predefined operators.
148 -- The form P."+" (x, y) requires additional handling.
150 -- Concatenation is treated more conventionally: for every one-dimensional
151 -- array type we introduce a explicit concatenation operator. This is
152 -- necessary to handle the case of (element & element => array) which
153 -- cannot be handled conveniently if there is no explicit instance of
154 -- resulting type of the operation.
156 -----------------------
157 -- Local Subprograms --
158 -----------------------
160 procedure All_Overloads;
161 pragma Warnings (Off, All_Overloads);
162 -- Debugging procedure: list full contents of Overloads table
164 function Binary_Op_Interp_Has_Abstract_Op
166 E : Entity_Id) return Entity_Id;
167 -- Given the node and entity of a binary operator, determine whether the
168 -- actuals of E contain an abstract interpretation with regards to the
169 -- types of their corresponding formals. Return the abstract operation or
172 function Function_Interp_Has_Abstract_Op
174 E : Entity_Id) return Entity_Id;
175 -- Given the node and entity of a function call, determine whether the
176 -- actuals of E contain an abstract interpretation with regards to the
177 -- types of their corresponding formals. Return the abstract operation or
180 function Has_Abstract_Op
182 Typ : Entity_Id) return Entity_Id;
183 -- Subsidiary routine to Binary_Op_Interp_Has_Abstract_Op and Function_
184 -- Interp_Has_Abstract_Op. Determine whether an overloaded node has an
185 -- abstract interpretation which yields type Typ.
187 procedure New_Interps (N : Node_Id);
188 -- Initialize collection of interpretations for the given node, which is
189 -- either an overloaded entity, or an operation whose arguments have
190 -- multiple interpretations. Interpretations can be added to only one
193 function Specific_Type (Typ_1, Typ_2 : Entity_Id) return Entity_Id;
194 -- If Typ_1 and Typ_2 are compatible, return the one that is not universal
195 -- or is not a "class" type (any_character, etc).
201 procedure Add_One_Interp
205 Opnd_Type : Entity_Id := Empty)
207 Vis_Type : Entity_Id;
209 procedure Add_Entry (Name : Entity_Id; Typ : Entity_Id);
210 -- Add one interpretation to an overloaded node. Add a new entry if
211 -- not hidden by previous one, and remove previous one if hidden by
214 function Is_Universal_Operation (Op : Entity_Id) return Boolean;
215 -- True if the entity is a predefined operator and the operands have
216 -- a universal Interpretation.
222 procedure Add_Entry (Name : Entity_Id; Typ : Entity_Id) is
223 Abstr_Op : Entity_Id := Empty;
227 -- Start of processing for Add_Entry
230 -- Find out whether the new entry references interpretations that
231 -- are abstract or disabled by abstract operators.
233 if Ada_Version >= Ada_2005 then
234 if Nkind (N) in N_Binary_Op then
235 Abstr_Op := Binary_Op_Interp_Has_Abstract_Op (N, Name);
236 elsif Nkind (N) = N_Function_Call then
237 Abstr_Op := Function_Interp_Has_Abstract_Op (N, Name);
241 Get_First_Interp (N, I, It);
242 while Present (It.Nam) loop
244 -- A user-defined subprogram hides another declared at an outer
245 -- level, or one that is use-visible. So return if previous
246 -- definition hides new one (which is either in an outer
247 -- scope, or use-visible). Note that for functions use-visible
248 -- is the same as potentially use-visible. If new one hides
249 -- previous one, replace entry in table of interpretations.
250 -- If this is a universal operation, retain the operator in case
251 -- preference rule applies.
253 if (((Ekind (Name) = E_Function or else Ekind (Name) = E_Procedure)
254 and then Ekind (Name) = Ekind (It.Nam))
255 or else (Ekind (Name) = E_Operator
256 and then Ekind (It.Nam) = E_Function))
258 and then Is_Immediately_Visible (It.Nam)
259 and then Type_Conformant (Name, It.Nam)
260 and then Base_Type (It.Typ) = Base_Type (T)
262 if Is_Universal_Operation (Name) then
265 -- If node is an operator symbol, we have no actuals with
266 -- which to check hiding, and this is done in full in the
267 -- caller (Analyze_Subprogram_Renaming) so we include the
268 -- predefined operator in any case.
270 elsif Nkind (N) = N_Operator_Symbol
271 or else (Nkind (N) = N_Expanded_Name
273 Nkind (Selector_Name (N)) = N_Operator_Symbol)
277 elsif not In_Open_Scopes (Scope (Name))
278 or else Scope_Depth (Scope (Name)) <=
279 Scope_Depth (Scope (It.Nam))
281 -- If ambiguity within instance, and entity is not an
282 -- implicit operation, save for later disambiguation.
284 if Scope (Name) = Scope (It.Nam)
285 and then not Is_Inherited_Operation (Name)
294 All_Interp.Table (I).Nam := Name;
298 -- Avoid making duplicate entries in overloads
301 and then Base_Type (It.Typ) = Base_Type (T)
305 -- Otherwise keep going
308 Get_Next_Interp (I, It);
313 All_Interp.Table (All_Interp.Last) := (Name, Typ, Abstr_Op);
314 All_Interp.Append (No_Interp);
317 ----------------------------
318 -- Is_Universal_Operation --
319 ----------------------------
321 function Is_Universal_Operation (Op : Entity_Id) return Boolean is
325 if Ekind (Op) /= E_Operator then
328 elsif Nkind (N) in N_Binary_Op then
329 return Present (Universal_Interpretation (Left_Opnd (N)))
330 and then Present (Universal_Interpretation (Right_Opnd (N)));
332 elsif Nkind (N) in N_Unary_Op then
333 return Present (Universal_Interpretation (Right_Opnd (N)));
335 elsif Nkind (N) = N_Function_Call then
336 Arg := First_Actual (N);
337 while Present (Arg) loop
338 if No (Universal_Interpretation (Arg)) then
350 end Is_Universal_Operation;
352 -- Start of processing for Add_One_Interp
355 -- If the interpretation is a predefined operator, verify that the
356 -- result type is visible, or that the entity has already been
357 -- resolved (case of an instantiation node that refers to a predefined
358 -- operation, or an internally generated operator node, or an operator
359 -- given as an expanded name). If the operator is a comparison or
360 -- equality, it is the type of the operand that matters to determine
361 -- whether the operator is visible. In an instance, the check is not
362 -- performed, given that the operator was visible in the generic.
364 if Ekind (E) = E_Operator then
365 if Present (Opnd_Type) then
366 Vis_Type := Opnd_Type;
368 Vis_Type := Base_Type (T);
371 if In_Open_Scopes (Scope (Vis_Type))
372 or else Is_Potentially_Use_Visible (Vis_Type)
373 or else In_Use (Vis_Type)
374 or else (In_Use (Scope (Vis_Type))
375 and then not Is_Hidden (Vis_Type))
376 or else Nkind (N) = N_Expanded_Name
377 or else (Nkind (N) in N_Op and then E = Entity (N))
379 or else Ekind (Vis_Type) = E_Anonymous_Access_Type
383 -- If the node is given in functional notation and the prefix
384 -- is an expanded name, then the operator is visible if the
385 -- prefix is the scope of the result type as well. If the
386 -- operator is (implicitly) defined in an extension of system,
387 -- it is know to be valid (see Defined_In_Scope, sem_ch4.adb).
389 elsif Nkind (N) = N_Function_Call
390 and then Nkind (Name (N)) = N_Expanded_Name
391 and then (Entity (Prefix (Name (N))) = Scope (Base_Type (T))
392 or else Entity (Prefix (Name (N))) = Scope (Vis_Type)
393 or else Scope (Vis_Type) = System_Aux_Id)
397 -- Save type for subsequent error message, in case no other
398 -- interpretation is found.
401 Candidate_Type := Vis_Type;
405 -- In an instance, an abstract non-dispatching operation cannot be a
406 -- candidate interpretation, because it could not have been one in the
407 -- generic (it may be a spurious overloading in the instance).
410 and then Is_Overloadable (E)
411 and then Is_Abstract_Subprogram (E)
412 and then not Is_Dispatching_Operation (E)
416 -- An inherited interface operation that is implemented by some derived
417 -- type does not participate in overload resolution, only the
418 -- implementation operation does.
421 and then Is_Subprogram (E)
422 and then Present (Interface_Alias (E))
424 -- Ada 2005 (AI-251): If this primitive operation corresponds with
425 -- an immediate ancestor interface there is no need to add it to the
426 -- list of interpretations. The corresponding aliased primitive is
427 -- also in this list of primitive operations and will be used instead
428 -- because otherwise we have a dummy ambiguity between the two
429 -- subprograms which are in fact the same.
432 (Find_Dispatching_Type (Interface_Alias (E)),
433 Find_Dispatching_Type (E))
435 Add_One_Interp (N, Interface_Alias (E), T);
440 -- Calling stubs for an RACW operation never participate in resolution,
441 -- they are executed only through dispatching calls.
443 elsif Is_RACW_Stub_Type_Operation (E) then
447 -- If this is the first interpretation of N, N has type Any_Type.
448 -- In that case place the new type on the node. If one interpretation
449 -- already exists, indicate that the node is overloaded, and store
450 -- both the previous and the new interpretation in All_Interp. If
451 -- this is a later interpretation, just add it to the set.
453 if Etype (N) = Any_Type then
458 -- Record both the operator or subprogram name, and its type
460 if Nkind (N) in N_Op or else Is_Entity_Name (N) then
467 -- Either there is no current interpretation in the table for any
468 -- node or the interpretation that is present is for a different
469 -- node. In both cases add a new interpretation to the table.
471 elsif Interp_Map.Last < 0
473 (Interp_Map.Table (Interp_Map.Last).Node /= N
474 and then not Is_Overloaded (N))
478 if (Nkind (N) in N_Op or else Is_Entity_Name (N))
479 and then Present (Entity (N))
481 Add_Entry (Entity (N), Etype (N));
483 elsif Nkind_In (N, N_Function_Call, N_Procedure_Call_Statement)
484 and then Is_Entity_Name (Name (N))
486 Add_Entry (Entity (Name (N)), Etype (N));
488 -- If this is an indirect call there will be no name associated
489 -- with the previous entry. To make diagnostics clearer, save
490 -- Subprogram_Type of first interpretation, so that the error will
491 -- point to the anonymous access to subprogram, not to the result
492 -- type of the call itself.
494 elsif (Nkind (N)) = N_Function_Call
495 and then Nkind (Name (N)) = N_Explicit_Dereference
496 and then Is_Overloaded (Name (N))
502 pragma Warnings (Off, Itn);
505 Get_First_Interp (Name (N), Itn, It);
506 Add_Entry (It.Nam, Etype (N));
510 -- Overloaded prefix in indexed or selected component, or call
511 -- whose name is an expression or another call.
513 Add_Entry (Etype (N), Etype (N));
527 procedure All_Overloads is
529 for J in All_Interp.First .. All_Interp.Last loop
531 if Present (All_Interp.Table (J).Nam) then
532 Write_Entity_Info (All_Interp.Table (J). Nam, " ");
534 Write_Str ("No Interp");
538 Write_Str ("=================");
543 --------------------------------------
544 -- Binary_Op_Interp_Has_Abstract_Op --
545 --------------------------------------
547 function Binary_Op_Interp_Has_Abstract_Op
549 E : Entity_Id) return Entity_Id
551 Abstr_Op : Entity_Id;
552 E_Left : constant Node_Id := First_Formal (E);
553 E_Right : constant Node_Id := Next_Formal (E_Left);
556 Abstr_Op := Has_Abstract_Op (Left_Opnd (N), Etype (E_Left));
557 if Present (Abstr_Op) then
561 return Has_Abstract_Op (Right_Opnd (N), Etype (E_Right));
562 end Binary_Op_Interp_Has_Abstract_Op;
564 ---------------------
565 -- Collect_Interps --
566 ---------------------
568 procedure Collect_Interps (N : Node_Id) is
569 Ent : constant Entity_Id := Entity (N);
571 First_Interp : Interp_Index;
576 -- Unconditionally add the entity that was initially matched
578 First_Interp := All_Interp.Last;
579 Add_One_Interp (N, Ent, Etype (N));
581 -- For expanded name, pick up all additional entities from the
582 -- same scope, since these are obviously also visible. Note that
583 -- these are not necessarily contiguous on the homonym chain.
585 if Nkind (N) = N_Expanded_Name then
587 while Present (H) loop
588 if Scope (H) = Scope (Entity (N)) then
589 Add_One_Interp (N, H, Etype (H));
595 -- Case of direct name
598 -- First, search the homonym chain for directly visible entities
600 H := Current_Entity (Ent);
601 while Present (H) loop
602 exit when (not Is_Overloadable (H))
603 and then Is_Immediately_Visible (H);
605 if Is_Immediately_Visible (H)
608 -- Only add interpretation if not hidden by an inner
609 -- immediately visible one.
611 for J in First_Interp .. All_Interp.Last - 1 loop
613 -- Current homograph is not hidden. Add to overloads
615 if not Is_Immediately_Visible (All_Interp.Table (J).Nam) then
618 -- Homograph is hidden, unless it is a predefined operator
620 elsif Type_Conformant (H, All_Interp.Table (J).Nam) then
622 -- A homograph in the same scope can occur within an
623 -- instantiation, the resulting ambiguity has to be
626 if Scope (H) = Scope (Ent)
628 and then not Is_Inherited_Operation (H)
630 All_Interp.Table (All_Interp.Last) :=
631 (H, Etype (H), Empty);
632 All_Interp.Append (No_Interp);
635 elsif Scope (H) /= Standard_Standard then
641 -- On exit, we know that current homograph is not hidden
643 Add_One_Interp (N, H, Etype (H));
646 Write_Str ("Add overloaded interpretation ");
656 -- Scan list of homographs for use-visible entities only
658 H := Current_Entity (Ent);
660 while Present (H) loop
661 if Is_Potentially_Use_Visible (H)
663 and then Is_Overloadable (H)
665 for J in First_Interp .. All_Interp.Last - 1 loop
667 if not Is_Immediately_Visible (All_Interp.Table (J).Nam) then
670 elsif Type_Conformant (H, All_Interp.Table (J).Nam) then
671 goto Next_Use_Homograph;
675 Add_One_Interp (N, H, Etype (H));
678 <<Next_Use_Homograph>>
683 if All_Interp.Last = First_Interp + 1 then
685 -- The final interpretation is in fact not overloaded. Note that the
686 -- unique legal interpretation may or may not be the original one,
687 -- so we need to update N's entity and etype now, because once N
688 -- is marked as not overloaded it is also expected to carry the
689 -- proper interpretation.
691 Set_Is_Overloaded (N, False);
692 Set_Entity (N, All_Interp.Table (First_Interp).Nam);
693 Set_Etype (N, All_Interp.Table (First_Interp).Typ);
701 function Covers (T1, T2 : Entity_Id) return Boolean is
706 function Full_View_Covers (Typ1, Typ2 : Entity_Id) return Boolean;
707 -- In an instance the proper view may not always be correct for
708 -- private types, but private and full view are compatible. This
709 -- removes spurious errors from nested instantiations that involve,
710 -- among other things, types derived from private types.
712 ----------------------
713 -- Full_View_Covers --
714 ----------------------
716 function Full_View_Covers (Typ1, Typ2 : Entity_Id) return Boolean is
719 Is_Private_Type (Typ1)
721 ((Present (Full_View (Typ1))
722 and then Covers (Full_View (Typ1), Typ2))
723 or else Base_Type (Typ1) = Typ2
724 or else Base_Type (Typ2) = Typ1);
725 end Full_View_Covers;
727 -- Start of processing for Covers
730 -- If either operand missing, then this is an error, but ignore it (and
731 -- pretend we have a cover) if errors already detected, since this may
732 -- simply mean we have malformed trees or a semantic error upstream.
734 if No (T1) or else No (T2) then
735 if Total_Errors_Detected /= 0 then
742 -- Trivial case: same types are always compatible
748 -- First check for Standard_Void_Type, which is special. Subsequent
749 -- processing in this routine assumes T1 and T2 are bona fide types;
750 -- Standard_Void_Type is a special entity that has some, but not all,
751 -- properties of types.
753 if (T1 = Standard_Void_Type) /= (T2 = Standard_Void_Type) then
757 BT1 := Base_Type (T1);
758 BT2 := Base_Type (T2);
760 -- Handle underlying view of records with unknown discriminants
761 -- using the original entity that motivated the construction of
762 -- this underlying record view (see Build_Derived_Private_Type).
764 if Is_Underlying_Record_View (BT1) then
765 BT1 := Underlying_Record_View (BT1);
768 if Is_Underlying_Record_View (BT2) then
769 BT2 := Underlying_Record_View (BT2);
772 -- Simplest case: types that have the same base type and are not generic
773 -- actuals are compatible. Generic actuals belong to their class but are
774 -- not compatible with other types of their class, and in particular
775 -- with other generic actuals. They are however compatible with their
776 -- own subtypes, and itypes with the same base are compatible as well.
777 -- Similarly, constrained subtypes obtained from expressions of an
778 -- unconstrained nominal type are compatible with the base type (may
779 -- lead to spurious ambiguities in obscure cases ???)
781 -- Generic actuals require special treatment to avoid spurious ambi-
782 -- guities in an instance, when two formal types are instantiated with
783 -- the same actual, so that different subprograms end up with the same
784 -- signature in the instance.
790 if not Is_Generic_Actual_Type (T1) then
793 return (not Is_Generic_Actual_Type (T2)
794 or else Is_Itype (T1)
795 or else Is_Itype (T2)
796 or else Is_Constr_Subt_For_U_Nominal (T1)
797 or else Is_Constr_Subt_For_U_Nominal (T2)
798 or else Scope (T1) /= Scope (T2));
801 -- Literals are compatible with types in a given "class"
803 elsif (T2 = Universal_Integer and then Is_Integer_Type (T1))
804 or else (T2 = Universal_Real and then Is_Real_Type (T1))
805 or else (T2 = Universal_Fixed and then Is_Fixed_Point_Type (T1))
806 or else (T2 = Any_Fixed and then Is_Fixed_Point_Type (T1))
807 or else (T2 = Any_String and then Is_String_Type (T1))
808 or else (T2 = Any_Character and then Is_Character_Type (T1))
809 or else (T2 = Any_Access and then Is_Access_Type (T1))
813 -- The context may be class wide, and a class-wide type is compatible
814 -- with any member of the class.
816 elsif Is_Class_Wide_Type (T1)
817 and then Is_Ancestor (Root_Type (T1), T2)
821 elsif Is_Class_Wide_Type (T1)
822 and then Is_Class_Wide_Type (T2)
823 and then Base_Type (Etype (T1)) = Base_Type (Etype (T2))
827 -- Ada 2005 (AI-345): A class-wide abstract interface type covers a
828 -- task_type or protected_type that implements the interface.
830 elsif Ada_Version >= Ada_2005
831 and then Is_Class_Wide_Type (T1)
832 and then Is_Interface (Etype (T1))
833 and then Is_Concurrent_Type (T2)
834 and then Interface_Present_In_Ancestor
835 (Typ => BT2, Iface => Etype (T1))
839 -- Ada 2005 (AI-251): A class-wide abstract interface type T1 covers an
840 -- object T2 implementing T1.
842 elsif Ada_Version >= Ada_2005
843 and then Is_Class_Wide_Type (T1)
844 and then Is_Interface (Etype (T1))
845 and then Is_Tagged_Type (T2)
847 if Interface_Present_In_Ancestor (Typ => T2,
858 if Is_Concurrent_Type (BT2) then
859 E := Corresponding_Record_Type (BT2);
864 -- Ada 2005 (AI-251): A class-wide abstract interface type T1
865 -- covers an object T2 that implements a direct derivation of T1.
866 -- Note: test for presence of E is defense against previous error.
869 and then Present (Interfaces (E))
871 Elmt := First_Elmt (Interfaces (E));
872 while Present (Elmt) loop
873 if Is_Ancestor (Etype (T1), Node (Elmt)) then
881 -- We should also check the case in which T1 is an ancestor of
882 -- some implemented interface???
887 -- In a dispatching call the actual may be class-wide, the formal
888 -- may be its specific type, or that of a descendent of it.
890 elsif Is_Class_Wide_Type (T2)
892 (Class_Wide_Type (T1) = T2
893 or else Base_Type (Root_Type (T2)) = BT1)
897 -- Some contexts require a class of types rather than a specific type.
898 -- For example, conditions require any boolean type, fixed point
899 -- attributes require some real type, etc. The built-in types Any_XXX
900 -- represent these classes.
902 elsif (T1 = Any_Integer and then Is_Integer_Type (T2))
903 or else (T1 = Any_Boolean and then Is_Boolean_Type (T2))
904 or else (T1 = Any_Real and then Is_Real_Type (T2))
905 or else (T1 = Any_Fixed and then Is_Fixed_Point_Type (T2))
906 or else (T1 = Any_Discrete and then Is_Discrete_Type (T2))
910 -- An aggregate is compatible with an array or record type
912 elsif T2 = Any_Composite
913 and then Is_Aggregate_Type (T1)
917 -- If the expected type is an anonymous access, the designated type must
918 -- cover that of the expression. Use the base type for this check: even
919 -- though access subtypes are rare in sources, they are generated for
920 -- actuals in instantiations.
922 elsif Ekind (BT1) = E_Anonymous_Access_Type
923 and then Is_Access_Type (T2)
924 and then Covers (Designated_Type (T1), Designated_Type (T2))
928 -- An Access_To_Subprogram is compatible with itself, or with an
929 -- anonymous type created for an attribute reference Access.
931 elsif (Ekind (BT1) = E_Access_Subprogram_Type
933 Ekind (BT1) = E_Access_Protected_Subprogram_Type)
934 and then Is_Access_Type (T2)
935 and then (not Comes_From_Source (T1)
936 or else not Comes_From_Source (T2))
937 and then (Is_Overloadable (Designated_Type (T2))
939 Ekind (Designated_Type (T2)) = E_Subprogram_Type)
941 Type_Conformant (Designated_Type (T1), Designated_Type (T2))
943 Mode_Conformant (Designated_Type (T1), Designated_Type (T2))
947 -- Ada 2005 (AI-254): An Anonymous_Access_To_Subprogram is compatible
948 -- with itself, or with an anonymous type created for an attribute
951 elsif (Ekind (BT1) = E_Anonymous_Access_Subprogram_Type
954 = E_Anonymous_Access_Protected_Subprogram_Type)
955 and then Is_Access_Type (T2)
956 and then (not Comes_From_Source (T1)
957 or else not Comes_From_Source (T2))
958 and then (Is_Overloadable (Designated_Type (T2))
960 Ekind (Designated_Type (T2)) = E_Subprogram_Type)
962 Type_Conformant (Designated_Type (T1), Designated_Type (T2))
964 Mode_Conformant (Designated_Type (T1), Designated_Type (T2))
968 -- The context can be a remote access type, and the expression the
969 -- corresponding source type declared in a categorized package, or
972 elsif Is_Record_Type (T1)
973 and then (Is_Remote_Call_Interface (T1)
974 or else Is_Remote_Types (T1))
975 and then Present (Corresponding_Remote_Type (T1))
977 return Covers (Corresponding_Remote_Type (T1), T2);
981 elsif Is_Record_Type (T2)
982 and then (Is_Remote_Call_Interface (T2)
983 or else Is_Remote_Types (T2))
984 and then Present (Corresponding_Remote_Type (T2))
986 return Covers (Corresponding_Remote_Type (T2), T1);
988 -- Synchronized types are represented at run time by their corresponding
989 -- record type. During expansion one is replaced with the other, but
990 -- they are compatible views of the same type.
992 elsif Is_Record_Type (T1)
993 and then Is_Concurrent_Type (T2)
994 and then Present (Corresponding_Record_Type (T2))
996 return Covers (T1, Corresponding_Record_Type (T2));
998 elsif Is_Concurrent_Type (T1)
999 and then Present (Corresponding_Record_Type (T1))
1000 and then Is_Record_Type (T2)
1002 return Covers (Corresponding_Record_Type (T1), T2);
1004 -- During analysis, an attribute reference 'Access has a special type
1005 -- kind: Access_Attribute_Type, to be replaced eventually with the type
1006 -- imposed by context.
1008 elsif Ekind (T2) = E_Access_Attribute_Type
1009 and then Ekind_In (BT1, E_General_Access_Type, E_Access_Type)
1010 and then Covers (Designated_Type (T1), Designated_Type (T2))
1012 -- If the target type is a RACW type while the source is an access
1013 -- attribute type, we are building a RACW that may be exported.
1015 if Is_Remote_Access_To_Class_Wide_Type (BT1) then
1016 Set_Has_RACW (Current_Sem_Unit);
1021 -- Ditto for allocators, which eventually resolve to the context type
1023 elsif Ekind (T2) = E_Allocator_Type
1024 and then Is_Access_Type (T1)
1026 return Covers (Designated_Type (T1), Designated_Type (T2))
1028 (From_With_Type (Designated_Type (T1))
1029 and then Covers (Designated_Type (T2), Designated_Type (T1)));
1031 -- A boolean operation on integer literals is compatible with modular
1034 elsif T2 = Any_Modular
1035 and then Is_Modular_Integer_Type (T1)
1039 -- The actual type may be the result of a previous error
1041 elsif BT2 = Any_Type then
1044 -- A packed array type covers its corresponding non-packed type. This is
1045 -- not legitimate Ada, but allows the omission of a number of otherwise
1046 -- useless unchecked conversions, and since this can only arise in
1047 -- (known correct) expanded code, no harm is done.
1049 elsif Is_Array_Type (T2)
1050 and then Is_Packed (T2)
1051 and then T1 = Packed_Array_Type (T2)
1055 -- Similarly an array type covers its corresponding packed array type
1057 elsif Is_Array_Type (T1)
1058 and then Is_Packed (T1)
1059 and then T2 = Packed_Array_Type (T1)
1063 -- In instances, or with types exported from instantiations, check
1064 -- whether a partial and a full view match. Verify that types are
1065 -- legal, to prevent cascaded errors.
1069 (Full_View_Covers (T1, T2)
1070 or else Full_View_Covers (T2, T1))
1075 and then Is_Generic_Actual_Type (T2)
1076 and then Full_View_Covers (T1, T2)
1081 and then Is_Generic_Actual_Type (T1)
1082 and then Full_View_Covers (T2, T1)
1086 -- In the expansion of inlined bodies, types are compatible if they
1087 -- are structurally equivalent.
1089 elsif In_Inlined_Body
1090 and then (Underlying_Type (T1) = Underlying_Type (T2)
1091 or else (Is_Access_Type (T1)
1092 and then Is_Access_Type (T2)
1094 Designated_Type (T1) = Designated_Type (T2))
1095 or else (T1 = Any_Access
1096 and then Is_Access_Type (Underlying_Type (T2)))
1097 or else (T2 = Any_Composite
1099 Is_Composite_Type (Underlying_Type (T1))))
1103 -- Ada 2005 (AI-50217): Additional branches to make the shadow entity
1104 -- obtained through a limited_with compatible with its real entity.
1106 elsif From_With_Type (T1) then
1108 -- If the expected type is the non-limited view of a type, the
1109 -- expression may have the limited view. If that one in turn is
1110 -- incomplete, get full view if available.
1112 if Is_Incomplete_Type (T1) then
1113 return Covers (Get_Full_View (Non_Limited_View (T1)), T2);
1115 elsif Ekind (T1) = E_Class_Wide_Type then
1117 Covers (Class_Wide_Type (Non_Limited_View (Etype (T1))), T2);
1122 elsif From_With_Type (T2) then
1124 -- If units in the context have Limited_With clauses on each other,
1125 -- either type might have a limited view. Checks performed elsewhere
1126 -- verify that the context type is the nonlimited view.
1128 if Is_Incomplete_Type (T2) then
1129 return Covers (T1, Get_Full_View (Non_Limited_View (T2)));
1131 elsif Ekind (T2) = E_Class_Wide_Type then
1133 Present (Non_Limited_View (Etype (T2)))
1135 Covers (T1, Class_Wide_Type (Non_Limited_View (Etype (T2))));
1140 -- Ada 2005 (AI-412): Coverage for regular incomplete subtypes
1142 elsif Ekind (T1) = E_Incomplete_Subtype then
1143 return Covers (Full_View (Etype (T1)), T2);
1145 elsif Ekind (T2) = E_Incomplete_Subtype then
1146 return Covers (T1, Full_View (Etype (T2)));
1148 -- Ada 2005 (AI-423): Coverage of formal anonymous access types
1149 -- and actual anonymous access types in the context of generic
1150 -- instantiations. We have the following situation:
1153 -- type Formal is private;
1154 -- Formal_Obj : access Formal; -- T1
1158 -- type Actual is ...
1159 -- Actual_Obj : access Actual; -- T2
1160 -- package Instance is new G (Formal => Actual,
1161 -- Formal_Obj => Actual_Obj);
1163 elsif Ada_Version >= Ada_2005
1164 and then Ekind (T1) = E_Anonymous_Access_Type
1165 and then Ekind (T2) = E_Anonymous_Access_Type
1166 and then Is_Generic_Type (Directly_Designated_Type (T1))
1167 and then Get_Instance_Of (Directly_Designated_Type (T1)) =
1168 Directly_Designated_Type (T2)
1172 -- Otherwise, types are not compatible!
1183 function Disambiguate
1185 I1, I2 : Interp_Index;
1186 Typ : Entity_Id) return Interp
1191 Nam1, Nam2 : Entity_Id;
1192 Predef_Subp : Entity_Id;
1193 User_Subp : Entity_Id;
1195 function Inherited_From_Actual (S : Entity_Id) return Boolean;
1196 -- Determine whether one of the candidates is an operation inherited by
1197 -- a type that is derived from an actual in an instantiation.
1199 function Is_Actual_Subprogram (S : Entity_Id) return Boolean;
1200 -- Determine whether a subprogram is an actual in an enclosing instance.
1201 -- An overloading between such a subprogram and one declared outside the
1202 -- instance is resolved in favor of the first, because it resolved in
1205 function Matches (Actual, Formal : Node_Id) return Boolean;
1206 -- Look for exact type match in an instance, to remove spurious
1207 -- ambiguities when two formal types have the same actual.
1209 function Standard_Operator return Boolean;
1210 -- Check whether subprogram is predefined operator declared in Standard.
1211 -- It may given by an operator name, or by an expanded name whose prefix
1214 function Remove_Conversions return Interp;
1215 -- Last chance for pathological cases involving comparisons on literals,
1216 -- and user overloadings of the same operator. Such pathologies have
1217 -- been removed from the ACVC, but still appear in two DEC tests, with
1218 -- the following notable quote from Ben Brosgol:
1220 -- [Note: I disclaim all credit/responsibility/blame for coming up with
1221 -- this example; Robert Dewar brought it to our attention, since it is
1222 -- apparently found in the ACVC 1.5. I did not attempt to find the
1223 -- reason in the Reference Manual that makes the example legal, since I
1224 -- was too nauseated by it to want to pursue it further.]
1226 -- Accordingly, this is not a fully recursive solution, but it handles
1227 -- DEC tests c460vsa, c460vsb. It also handles ai00136a, which pushes
1228 -- pathology in the other direction with calls whose multiple overloaded
1229 -- actuals make them truly unresolvable.
1231 -- The new rules concerning abstract operations create additional need
1232 -- for special handling of expressions with universal operands, see
1233 -- comments to Has_Abstract_Interpretation below.
1235 ---------------------------
1236 -- Inherited_From_Actual --
1237 ---------------------------
1239 function Inherited_From_Actual (S : Entity_Id) return Boolean is
1240 Par : constant Node_Id := Parent (S);
1242 if Nkind (Par) /= N_Full_Type_Declaration
1243 or else Nkind (Type_Definition (Par)) /= N_Derived_Type_Definition
1247 return Is_Entity_Name (Subtype_Indication (Type_Definition (Par)))
1249 Is_Generic_Actual_Type (
1250 Entity (Subtype_Indication (Type_Definition (Par))));
1252 end Inherited_From_Actual;
1254 --------------------------
1255 -- Is_Actual_Subprogram --
1256 --------------------------
1258 function Is_Actual_Subprogram (S : Entity_Id) return Boolean is
1260 return In_Open_Scopes (Scope (S))
1262 (Is_Generic_Instance (Scope (S))
1263 or else Is_Wrapper_Package (Scope (S)));
1264 end Is_Actual_Subprogram;
1270 function Matches (Actual, Formal : Node_Id) return Boolean is
1271 T1 : constant Entity_Id := Etype (Actual);
1272 T2 : constant Entity_Id := Etype (Formal);
1276 (Is_Numeric_Type (T2)
1277 and then (T1 = Universal_Real or else T1 = Universal_Integer));
1280 ------------------------
1281 -- Remove_Conversions --
1282 ------------------------
1284 function Remove_Conversions return Interp is
1292 function Has_Abstract_Interpretation (N : Node_Id) return Boolean;
1293 -- If an operation has universal operands the universal operation
1294 -- is present among its interpretations. If there is an abstract
1295 -- interpretation for the operator, with a numeric result, this
1296 -- interpretation was already removed in sem_ch4, but the universal
1297 -- one is still visible. We must rescan the list of operators and
1298 -- remove the universal interpretation to resolve the ambiguity.
1300 ---------------------------------
1301 -- Has_Abstract_Interpretation --
1302 ---------------------------------
1304 function Has_Abstract_Interpretation (N : Node_Id) return Boolean is
1308 if Nkind (N) not in N_Op
1309 or else Ada_Version < Ada_2005
1310 or else not Is_Overloaded (N)
1311 or else No (Universal_Interpretation (N))
1316 E := Get_Name_Entity_Id (Chars (N));
1317 while Present (E) loop
1318 if Is_Overloadable (E)
1319 and then Is_Abstract_Subprogram (E)
1320 and then Is_Numeric_Type (Etype (E))
1328 -- Finally, if an operand of the binary operator is itself
1329 -- an operator, recurse to see whether its own abstract
1330 -- interpretation is responsible for the spurious ambiguity.
1332 if Nkind (N) in N_Binary_Op then
1333 return Has_Abstract_Interpretation (Left_Opnd (N))
1334 or else Has_Abstract_Interpretation (Right_Opnd (N));
1336 elsif Nkind (N) in N_Unary_Op then
1337 return Has_Abstract_Interpretation (Right_Opnd (N));
1343 end Has_Abstract_Interpretation;
1345 -- Start of processing for Remove_Conversions
1350 Get_First_Interp (N, I, It);
1351 while Present (It.Typ) loop
1352 if not Is_Overloadable (It.Nam) then
1356 F1 := First_Formal (It.Nam);
1362 if Nkind (N) = N_Function_Call
1363 or else Nkind (N) = N_Procedure_Call_Statement
1365 Act1 := First_Actual (N);
1367 if Present (Act1) then
1368 Act2 := Next_Actual (Act1);
1373 elsif Nkind (N) in N_Unary_Op then
1374 Act1 := Right_Opnd (N);
1377 elsif Nkind (N) in N_Binary_Op then
1378 Act1 := Left_Opnd (N);
1379 Act2 := Right_Opnd (N);
1381 -- Use type of second formal, so as to include
1382 -- exponentiation, where the exponent may be
1383 -- ambiguous and the result non-universal.
1391 if Nkind (Act1) in N_Op
1392 and then Is_Overloaded (Act1)
1393 and then (Nkind (Right_Opnd (Act1)) = N_Integer_Literal
1394 or else Nkind (Right_Opnd (Act1)) = N_Real_Literal)
1395 and then Has_Compatible_Type (Act1, Standard_Boolean)
1396 and then Etype (F1) = Standard_Boolean
1398 -- If the two candidates are the original ones, the
1399 -- ambiguity is real. Otherwise keep the original, further
1400 -- calls to Disambiguate will take care of others in the
1401 -- list of candidates.
1403 if It1 /= No_Interp then
1404 if It = Disambiguate.It1
1405 or else It = Disambiguate.It2
1407 if It1 = Disambiguate.It1
1408 or else It1 = Disambiguate.It2
1416 elsif Present (Act2)
1417 and then Nkind (Act2) in N_Op
1418 and then Is_Overloaded (Act2)
1419 and then Nkind_In (Right_Opnd (Act2), N_Integer_Literal,
1421 and then Has_Compatible_Type (Act2, Standard_Boolean)
1423 -- The preference rule on the first actual is not
1424 -- sufficient to disambiguate.
1432 elsif Is_Numeric_Type (Etype (F1))
1433 and then Has_Abstract_Interpretation (Act1)
1435 -- Current interpretation is not the right one because it
1436 -- expects a numeric operand. Examine all the other ones.
1443 Get_First_Interp (N, I, It);
1444 while Present (It.Typ) loop
1446 not Is_Numeric_Type (Etype (First_Formal (It.Nam)))
1449 or else not Has_Abstract_Interpretation (Act2)
1452 (Etype (Next_Formal (First_Formal (It.Nam))))
1458 Get_Next_Interp (I, It);
1467 Get_Next_Interp (I, It);
1470 -- After some error, a formal may have Any_Type and yield a spurious
1471 -- match. To avoid cascaded errors if possible, check for such a
1472 -- formal in either candidate.
1474 if Serious_Errors_Detected > 0 then
1479 Formal := First_Formal (Nam1);
1480 while Present (Formal) loop
1481 if Etype (Formal) = Any_Type then
1482 return Disambiguate.It2;
1485 Next_Formal (Formal);
1488 Formal := First_Formal (Nam2);
1489 while Present (Formal) loop
1490 if Etype (Formal) = Any_Type then
1491 return Disambiguate.It1;
1494 Next_Formal (Formal);
1500 end Remove_Conversions;
1502 -----------------------
1503 -- Standard_Operator --
1504 -----------------------
1506 function Standard_Operator return Boolean is
1510 if Nkind (N) in N_Op then
1513 elsif Nkind (N) = N_Function_Call then
1516 if Nkind (Nam) /= N_Expanded_Name then
1519 return Entity (Prefix (Nam)) = Standard_Standard;
1524 end Standard_Operator;
1526 -- Start of processing for Disambiguate
1529 -- Recover the two legal interpretations
1531 Get_First_Interp (N, I, It);
1533 Get_Next_Interp (I, It);
1539 Get_Next_Interp (I, It);
1545 -- Check whether one of the entities is an Ada 2005/2012 and we are
1546 -- operating in an earlier mode, in which case we discard the Ada
1547 -- 2005/2012 entity, so that we get proper Ada 95 overload resolution.
1549 if Ada_Version < Ada_2005 then
1550 if Is_Ada_2005_Only (Nam1) or else Is_Ada_2012_Only (Nam1) then
1552 elsif Is_Ada_2005_Only (Nam2) or else Is_Ada_2012_Only (Nam1) then
1557 -- Check whether one of the entities is an Ada 2012 entity and we are
1558 -- operating in Ada 2005 mode, in which case we discard the Ada 2012
1559 -- entity, so that we get proper Ada 2005 overload resolution.
1561 if Ada_Version = Ada_2005 then
1562 if Is_Ada_2012_Only (Nam1) then
1564 elsif Is_Ada_2012_Only (Nam2) then
1569 -- Check for overloaded CIL convention stuff because the CIL libraries
1570 -- do sick things like Console.Write_Line where it matches two different
1571 -- overloads, so just pick the first ???
1573 if Convention (Nam1) = Convention_CIL
1574 and then Convention (Nam2) = Convention_CIL
1575 and then Ekind (Nam1) = Ekind (Nam2)
1576 and then (Ekind (Nam1) = E_Procedure
1577 or else Ekind (Nam1) = E_Function)
1582 -- If the context is universal, the predefined operator is preferred.
1583 -- This includes bounds in numeric type declarations, and expressions
1584 -- in type conversions. If no interpretation yields a universal type,
1585 -- then we must check whether the user-defined entity hides the prede-
1588 if Chars (Nam1) in Any_Operator_Name
1589 and then Standard_Operator
1591 if Typ = Universal_Integer
1592 or else Typ = Universal_Real
1593 or else Typ = Any_Integer
1594 or else Typ = Any_Discrete
1595 or else Typ = Any_Real
1596 or else Typ = Any_Type
1598 -- Find an interpretation that yields the universal type, or else
1599 -- a predefined operator that yields a predefined numeric type.
1602 Candidate : Interp := No_Interp;
1605 Get_First_Interp (N, I, It);
1606 while Present (It.Typ) loop
1607 if (Covers (Typ, It.Typ)
1608 or else Typ = Any_Type)
1610 (It.Typ = Universal_Integer
1611 or else It.Typ = Universal_Real)
1615 elsif Covers (Typ, It.Typ)
1616 and then Scope (It.Typ) = Standard_Standard
1617 and then Scope (It.Nam) = Standard_Standard
1618 and then Is_Numeric_Type (It.Typ)
1623 Get_Next_Interp (I, It);
1626 if Candidate /= No_Interp then
1631 elsif Chars (Nam1) /= Name_Op_Not
1632 and then (Typ = Standard_Boolean or else Typ = Any_Boolean)
1634 -- Equality or comparison operation. Choose predefined operator if
1635 -- arguments are universal. The node may be an operator, name, or
1636 -- a function call, so unpack arguments accordingly.
1639 Arg1, Arg2 : Node_Id;
1642 if Nkind (N) in N_Op then
1643 Arg1 := Left_Opnd (N);
1644 Arg2 := Right_Opnd (N);
1646 elsif Is_Entity_Name (N) then
1647 Arg1 := First_Entity (Entity (N));
1648 Arg2 := Next_Entity (Arg1);
1651 Arg1 := First_Actual (N);
1652 Arg2 := Next_Actual (Arg1);
1656 and then Present (Universal_Interpretation (Arg1))
1657 and then Universal_Interpretation (Arg2) =
1658 Universal_Interpretation (Arg1)
1660 Get_First_Interp (N, I, It);
1661 while Scope (It.Nam) /= Standard_Standard loop
1662 Get_Next_Interp (I, It);
1671 -- If no universal interpretation, check whether user-defined operator
1672 -- hides predefined one, as well as other special cases. If the node
1673 -- is a range, then one or both bounds are ambiguous. Each will have
1674 -- to be disambiguated w.r.t. the context type. The type of the range
1675 -- itself is imposed by the context, so we can return either legal
1678 if Ekind (Nam1) = E_Operator then
1679 Predef_Subp := Nam1;
1682 elsif Ekind (Nam2) = E_Operator then
1683 Predef_Subp := Nam2;
1686 elsif Nkind (N) = N_Range then
1689 -- Implement AI05-105: A renaming declaration with an access
1690 -- definition must resolve to an anonymous access type. This
1691 -- is a resolution rule and can be used to disambiguate.
1693 elsif Nkind (Parent (N)) = N_Object_Renaming_Declaration
1694 and then Present (Access_Definition (Parent (N)))
1696 if Ekind_In (It1.Typ, E_Anonymous_Access_Type,
1697 E_Anonymous_Access_Subprogram_Type)
1699 if Ekind (It2.Typ) = Ekind (It1.Typ) then
1709 elsif Ekind_In (It2.Typ, E_Anonymous_Access_Type,
1710 E_Anonymous_Access_Subprogram_Type)
1714 -- No legal interpretation
1720 -- If two user defined-subprograms are visible, it is a true ambiguity,
1721 -- unless one of them is an entry and the context is a conditional or
1722 -- timed entry call, or unless we are within an instance and this is
1723 -- results from two formals types with the same actual.
1726 if Nkind (N) = N_Procedure_Call_Statement
1727 and then Nkind (Parent (N)) = N_Entry_Call_Alternative
1728 and then N = Entry_Call_Statement (Parent (N))
1730 if Ekind (Nam2) = E_Entry then
1732 elsif Ekind (Nam1) = E_Entry then
1738 -- If the ambiguity occurs within an instance, it is due to several
1739 -- formal types with the same actual. Look for an exact match between
1740 -- the types of the formals of the overloadable entities, and the
1741 -- actuals in the call, to recover the unambiguous match in the
1742 -- original generic.
1744 -- The ambiguity can also be due to an overloading between a formal
1745 -- subprogram and a subprogram declared outside the generic. If the
1746 -- node is overloaded, it did not resolve to the global entity in
1747 -- the generic, and we choose the formal subprogram.
1749 -- Finally, the ambiguity can be between an explicit subprogram and
1750 -- one inherited (with different defaults) from an actual. In this
1751 -- case the resolution was to the explicit declaration in the
1752 -- generic, and remains so in the instance.
1754 -- The same sort of disambiguation needed for calls is also required
1755 -- for the name given in a subprogram renaming, and that case is
1756 -- handled here as well. We test Comes_From_Source to exclude this
1757 -- treatment for implicit renamings created for formal subprograms.
1760 and then not In_Generic_Actual (N)
1762 if Nkind (N) = N_Function_Call
1763 or else Nkind (N) = N_Procedure_Call_Statement
1765 (Nkind (N) in N_Has_Entity
1767 Nkind (Parent (N)) = N_Subprogram_Renaming_Declaration
1768 and then Comes_From_Source (Parent (N)))
1773 Renam : Entity_Id := Empty;
1774 Is_Act1 : constant Boolean := Is_Actual_Subprogram (Nam1);
1775 Is_Act2 : constant Boolean := Is_Actual_Subprogram (Nam2);
1778 if Is_Act1 and then not Is_Act2 then
1781 elsif Is_Act2 and then not Is_Act1 then
1784 elsif Inherited_From_Actual (Nam1)
1785 and then Comes_From_Source (Nam2)
1789 elsif Inherited_From_Actual (Nam2)
1790 and then Comes_From_Source (Nam1)
1795 -- In the case of a renamed subprogram, pick up the entity
1796 -- of the renaming declaration so we can traverse its
1797 -- formal parameters.
1799 if Nkind (N) in N_Has_Entity then
1800 Renam := Defining_Unit_Name (Specification (Parent (N)));
1803 if Present (Renam) then
1804 Actual := First_Formal (Renam);
1806 Actual := First_Actual (N);
1809 Formal := First_Formal (Nam1);
1810 while Present (Actual) loop
1811 if Etype (Actual) /= Etype (Formal) then
1815 if Present (Renam) then
1816 Next_Formal (Actual);
1818 Next_Actual (Actual);
1821 Next_Formal (Formal);
1827 elsif Nkind (N) in N_Binary_Op then
1828 if Matches (Left_Opnd (N), First_Formal (Nam1))
1830 Matches (Right_Opnd (N), Next_Formal (First_Formal (Nam1)))
1837 elsif Nkind (N) in N_Unary_Op then
1838 if Etype (Right_Opnd (N)) = Etype (First_Formal (Nam1)) then
1845 return Remove_Conversions;
1848 return Remove_Conversions;
1852 -- An implicit concatenation operator on a string type cannot be
1853 -- disambiguated from the predefined concatenation. This can only
1854 -- happen with concatenation of string literals.
1856 if Chars (User_Subp) = Name_Op_Concat
1857 and then Ekind (User_Subp) = E_Operator
1858 and then Is_String_Type (Etype (First_Formal (User_Subp)))
1862 -- If the user-defined operator is in an open scope, or in the scope
1863 -- of the resulting type, or given by an expanded name that names its
1864 -- scope, it hides the predefined operator for the type. Exponentiation
1865 -- has to be special-cased because the implicit operator does not have
1866 -- a symmetric signature, and may not be hidden by the explicit one.
1868 elsif (Nkind (N) = N_Function_Call
1869 and then Nkind (Name (N)) = N_Expanded_Name
1870 and then (Chars (Predef_Subp) /= Name_Op_Expon
1871 or else Hides_Op (User_Subp, Predef_Subp))
1872 and then Scope (User_Subp) = Entity (Prefix (Name (N))))
1873 or else Hides_Op (User_Subp, Predef_Subp)
1875 if It1.Nam = User_Subp then
1881 -- Otherwise, the predefined operator has precedence, or if the user-
1882 -- defined operation is directly visible we have a true ambiguity. If
1883 -- this is a fixed-point multiplication and division in Ada83 mode,
1884 -- exclude the universal_fixed operator, which often causes ambiguities
1888 if (In_Open_Scopes (Scope (User_Subp))
1889 or else Is_Potentially_Use_Visible (User_Subp))
1890 and then not In_Instance
1892 if Is_Fixed_Point_Type (Typ)
1893 and then (Chars (Nam1) = Name_Op_Multiply
1894 or else Chars (Nam1) = Name_Op_Divide)
1895 and then Ada_Version = Ada_83
1897 if It2.Nam = Predef_Subp then
1903 -- Ada 2005, AI-420: preference rule for "=" on Universal_Access
1904 -- states that the operator defined in Standard is not available
1905 -- if there is a user-defined equality with the proper signature,
1906 -- declared in the same declarative list as the type. The node
1907 -- may be an operator or a function call.
1909 elsif (Chars (Nam1) = Name_Op_Eq
1911 Chars (Nam1) = Name_Op_Ne)
1912 and then Ada_Version >= Ada_2005
1913 and then Etype (User_Subp) = Standard_Boolean
1919 if Nkind (N) = N_Function_Call then
1920 Opnd := First_Actual (N);
1922 Opnd := Left_Opnd (N);
1925 if Ekind (Etype (Opnd)) = E_Anonymous_Access_Type
1927 In_Same_List (Parent (Designated_Type (Etype (Opnd))),
1928 Unit_Declaration_Node (User_Subp))
1930 if It2.Nam = Predef_Subp then
1936 return Remove_Conversions;
1940 -- An immediately visible operator hides a use-visible user-
1941 -- defined operation. This disambiguation cannot take place
1942 -- earlier because the visibility of the predefined operator
1943 -- can only be established when operand types are known.
1945 elsif Ekind (User_Subp) = E_Function
1946 and then Ekind (Predef_Subp) = E_Operator
1947 and then Nkind (N) in N_Op
1948 and then not Is_Overloaded (Right_Opnd (N))
1950 Is_Immediately_Visible (Base_Type (Etype (Right_Opnd (N))))
1951 and then Is_Potentially_Use_Visible (User_Subp)
1953 if It2.Nam = Predef_Subp then
1963 elsif It1.Nam = Predef_Subp then
1972 ---------------------
1973 -- End_Interp_List --
1974 ---------------------
1976 procedure End_Interp_List is
1978 All_Interp.Table (All_Interp.Last) := No_Interp;
1979 All_Interp.Increment_Last;
1980 end End_Interp_List;
1982 -------------------------
1983 -- Entity_Matches_Spec --
1984 -------------------------
1986 function Entity_Matches_Spec (Old_S, New_S : Entity_Id) return Boolean is
1988 -- Simple case: same entity kinds, type conformance is required. A
1989 -- parameterless function can also rename a literal.
1991 if Ekind (Old_S) = Ekind (New_S)
1992 or else (Ekind (New_S) = E_Function
1993 and then Ekind (Old_S) = E_Enumeration_Literal)
1995 return Type_Conformant (New_S, Old_S);
1997 elsif Ekind (New_S) = E_Function
1998 and then Ekind (Old_S) = E_Operator
2000 return Operator_Matches_Spec (Old_S, New_S);
2002 elsif Ekind (New_S) = E_Procedure
2003 and then Is_Entry (Old_S)
2005 return Type_Conformant (New_S, Old_S);
2010 end Entity_Matches_Spec;
2012 ----------------------
2013 -- Find_Unique_Type --
2014 ----------------------
2016 function Find_Unique_Type (L : Node_Id; R : Node_Id) return Entity_Id is
2017 T : constant Entity_Id := Etype (L);
2020 TR : Entity_Id := Any_Type;
2023 if Is_Overloaded (R) then
2024 Get_First_Interp (R, I, It);
2025 while Present (It.Typ) loop
2026 if Covers (T, It.Typ) or else Covers (It.Typ, T) then
2028 -- If several interpretations are possible and L is universal,
2029 -- apply preference rule.
2031 if TR /= Any_Type then
2033 if (T = Universal_Integer or else T = Universal_Real)
2044 Get_Next_Interp (I, It);
2049 -- In the non-overloaded case, the Etype of R is already set correctly
2055 -- If one of the operands is Universal_Fixed, the type of the other
2056 -- operand provides the context.
2058 if Etype (R) = Universal_Fixed then
2061 elsif T = Universal_Fixed then
2064 -- Ada 2005 (AI-230): Support the following operators:
2066 -- function "=" (L, R : universal_access) return Boolean;
2067 -- function "/=" (L, R : universal_access) return Boolean;
2069 -- Pool specific access types (E_Access_Type) are not covered by these
2070 -- operators because of the legality rule of 4.5.2(9.2): "The operands
2071 -- of the equality operators for universal_access shall be convertible
2072 -- to one another (see 4.6)". For example, considering the type decla-
2073 -- ration "type P is access Integer" and an anonymous access to Integer,
2074 -- P is convertible to "access Integer" by 4.6 (24.11-24.15), but there
2075 -- is no rule in 4.6 that allows "access Integer" to be converted to P.
2077 elsif Ada_Version >= Ada_2005
2079 (Ekind (Etype (L)) = E_Anonymous_Access_Type
2081 Ekind (Etype (L)) = E_Anonymous_Access_Subprogram_Type)
2082 and then Is_Access_Type (Etype (R))
2083 and then Ekind (Etype (R)) /= E_Access_Type
2087 elsif Ada_Version >= Ada_2005
2089 (Ekind (Etype (R)) = E_Anonymous_Access_Type
2090 or else Ekind (Etype (R)) = E_Anonymous_Access_Subprogram_Type)
2091 and then Is_Access_Type (Etype (L))
2092 and then Ekind (Etype (L)) /= E_Access_Type
2097 return Specific_Type (T, Etype (R));
2099 end Find_Unique_Type;
2101 -------------------------------------
2102 -- Function_Interp_Has_Abstract_Op --
2103 -------------------------------------
2105 function Function_Interp_Has_Abstract_Op
2107 E : Entity_Id) return Entity_Id
2109 Abstr_Op : Entity_Id;
2112 Form_Parm : Node_Id;
2115 -- Why is check on E needed below ???
2116 -- In any case this para needs comments ???
2118 if Is_Overloaded (N) and then Is_Overloadable (E) then
2119 Act_Parm := First_Actual (N);
2120 Form_Parm := First_Formal (E);
2121 while Present (Act_Parm)
2122 and then Present (Form_Parm)
2126 if Nkind (Act) = N_Parameter_Association then
2127 Act := Explicit_Actual_Parameter (Act);
2130 Abstr_Op := Has_Abstract_Op (Act, Etype (Form_Parm));
2132 if Present (Abstr_Op) then
2136 Next_Actual (Act_Parm);
2137 Next_Formal (Form_Parm);
2142 end Function_Interp_Has_Abstract_Op;
2144 ----------------------
2145 -- Get_First_Interp --
2146 ----------------------
2148 procedure Get_First_Interp
2150 I : out Interp_Index;
2153 Int_Ind : Interp_Index;
2158 -- If a selected component is overloaded because the selector has
2159 -- multiple interpretations, the node is a call to a protected
2160 -- operation or an indirect call. Retrieve the interpretation from
2161 -- the selector name. The selected component may be overloaded as well
2162 -- if the prefix is overloaded. That case is unchanged.
2164 if Nkind (N) = N_Selected_Component
2165 and then Is_Overloaded (Selector_Name (N))
2167 O_N := Selector_Name (N);
2172 Map_Ptr := Headers (Hash (O_N));
2173 while Map_Ptr /= No_Entry loop
2174 if Interp_Map.Table (Map_Ptr).Node = O_N then
2175 Int_Ind := Interp_Map.Table (Map_Ptr).Index;
2176 It := All_Interp.Table (Int_Ind);
2180 Map_Ptr := Interp_Map.Table (Map_Ptr).Next;
2184 -- Procedure should never be called if the node has no interpretations
2186 raise Program_Error;
2187 end Get_First_Interp;
2189 ---------------------
2190 -- Get_Next_Interp --
2191 ---------------------
2193 procedure Get_Next_Interp (I : in out Interp_Index; It : out Interp) is
2196 It := All_Interp.Table (I);
2197 end Get_Next_Interp;
2199 -------------------------
2200 -- Has_Compatible_Type --
2201 -------------------------
2203 function Has_Compatible_Type
2205 Typ : Entity_Id) return Boolean
2215 if Nkind (N) = N_Subtype_Indication
2216 or else not Is_Overloaded (N)
2219 Covers (Typ, Etype (N))
2221 -- Ada 2005 (AI-345): The context may be a synchronized interface.
2222 -- If the type is already frozen use the corresponding_record
2223 -- to check whether it is a proper descendant.
2226 (Is_Record_Type (Typ)
2227 and then Is_Concurrent_Type (Etype (N))
2228 and then Present (Corresponding_Record_Type (Etype (N)))
2229 and then Covers (Typ, Corresponding_Record_Type (Etype (N))))
2232 (Is_Concurrent_Type (Typ)
2233 and then Is_Record_Type (Etype (N))
2234 and then Present (Corresponding_Record_Type (Typ))
2235 and then Covers (Corresponding_Record_Type (Typ), Etype (N)))
2238 (not Is_Tagged_Type (Typ)
2239 and then Ekind (Typ) /= E_Anonymous_Access_Type
2240 and then Covers (Etype (N), Typ));
2243 Get_First_Interp (N, I, It);
2244 while Present (It.Typ) loop
2245 if (Covers (Typ, It.Typ)
2247 (Scope (It.Nam) /= Standard_Standard
2248 or else not Is_Invisible_Operator (N, Base_Type (Typ))))
2250 -- Ada 2005 (AI-345)
2253 (Is_Concurrent_Type (It.Typ)
2254 and then Present (Corresponding_Record_Type
2256 and then Covers (Typ, Corresponding_Record_Type
2259 or else (not Is_Tagged_Type (Typ)
2260 and then Ekind (Typ) /= E_Anonymous_Access_Type
2261 and then Covers (It.Typ, Typ))
2266 Get_Next_Interp (I, It);
2271 end Has_Compatible_Type;
2273 ---------------------
2274 -- Has_Abstract_Op --
2275 ---------------------
2277 function Has_Abstract_Op
2279 Typ : Entity_Id) return Entity_Id
2285 if Is_Overloaded (N) then
2286 Get_First_Interp (N, I, It);
2287 while Present (It.Nam) loop
2288 if Present (It.Abstract_Op)
2289 and then Etype (It.Abstract_Op) = Typ
2291 return It.Abstract_Op;
2294 Get_Next_Interp (I, It);
2299 end Has_Abstract_Op;
2305 function Hash (N : Node_Id) return Int is
2307 -- Nodes have a size that is power of two, so to select significant
2308 -- bits only we remove the low-order bits.
2310 return ((Int (N) / 2 ** 5) mod Header_Size);
2317 function Hides_Op (F : Entity_Id; Op : Entity_Id) return Boolean is
2318 Btyp : constant Entity_Id := Base_Type (Etype (First_Formal (F)));
2320 return Operator_Matches_Spec (Op, F)
2321 and then (In_Open_Scopes (Scope (F))
2322 or else Scope (F) = Scope (Btyp)
2323 or else (not In_Open_Scopes (Scope (Btyp))
2324 and then not In_Use (Btyp)
2325 and then not In_Use (Scope (Btyp))));
2328 ------------------------
2329 -- Init_Interp_Tables --
2330 ------------------------
2332 procedure Init_Interp_Tables is
2336 Headers := (others => No_Entry);
2337 end Init_Interp_Tables;
2339 -----------------------------------
2340 -- Interface_Present_In_Ancestor --
2341 -----------------------------------
2343 function Interface_Present_In_Ancestor
2345 Iface : Entity_Id) return Boolean
2347 Target_Typ : Entity_Id;
2348 Iface_Typ : Entity_Id;
2350 function Iface_Present_In_Ancestor (Typ : Entity_Id) return Boolean;
2351 -- Returns True if Typ or some ancestor of Typ implements Iface
2353 -------------------------------
2354 -- Iface_Present_In_Ancestor --
2355 -------------------------------
2357 function Iface_Present_In_Ancestor (Typ : Entity_Id) return Boolean is
2363 if Typ = Iface_Typ then
2367 -- Handle private types
2369 if Present (Full_View (Typ))
2370 and then not Is_Concurrent_Type (Full_View (Typ))
2372 E := Full_View (Typ);
2378 if Present (Interfaces (E))
2379 and then Present (Interfaces (E))
2380 and then not Is_Empty_Elmt_List (Interfaces (E))
2382 Elmt := First_Elmt (Interfaces (E));
2383 while Present (Elmt) loop
2386 if AI = Iface_Typ or else Is_Ancestor (Iface_Typ, AI) then
2394 exit when Etype (E) = E
2396 -- Handle private types
2398 or else (Present (Full_View (Etype (E)))
2399 and then Full_View (Etype (E)) = E);
2401 -- Check if the current type is a direct derivation of the
2404 if Etype (E) = Iface_Typ then
2408 -- Climb to the immediate ancestor handling private types
2410 if Present (Full_View (Etype (E))) then
2411 E := Full_View (Etype (E));
2418 end Iface_Present_In_Ancestor;
2420 -- Start of processing for Interface_Present_In_Ancestor
2423 -- Iface might be a class-wide subtype, so we have to apply Base_Type
2425 if Is_Class_Wide_Type (Iface) then
2426 Iface_Typ := Etype (Base_Type (Iface));
2433 Iface_Typ := Base_Type (Iface_Typ);
2435 if Is_Access_Type (Typ) then
2436 Target_Typ := Etype (Directly_Designated_Type (Typ));
2441 if Is_Concurrent_Record_Type (Target_Typ) then
2442 Target_Typ := Corresponding_Concurrent_Type (Target_Typ);
2445 Target_Typ := Base_Type (Target_Typ);
2447 -- In case of concurrent types we can't use the Corresponding Record_Typ
2448 -- to look for the interface because it is built by the expander (and
2449 -- hence it is not always available). For this reason we traverse the
2450 -- list of interfaces (available in the parent of the concurrent type)
2452 if Is_Concurrent_Type (Target_Typ) then
2453 if Present (Interface_List (Parent (Target_Typ))) then
2458 AI := First (Interface_List (Parent (Target_Typ)));
2459 while Present (AI) loop
2460 if Etype (AI) = Iface_Typ then
2463 elsif Present (Interfaces (Etype (AI)))
2464 and then Iface_Present_In_Ancestor (Etype (AI))
2477 if Is_Class_Wide_Type (Target_Typ) then
2478 Target_Typ := Etype (Target_Typ);
2481 if Ekind (Target_Typ) = E_Incomplete_Type then
2482 pragma Assert (Present (Non_Limited_View (Target_Typ)));
2483 Target_Typ := Non_Limited_View (Target_Typ);
2485 -- Protect the frontend against previously detected errors
2487 if Ekind (Target_Typ) = E_Incomplete_Type then
2492 return Iface_Present_In_Ancestor (Target_Typ);
2493 end Interface_Present_In_Ancestor;
2495 ---------------------
2496 -- Intersect_Types --
2497 ---------------------
2499 function Intersect_Types (L, R : Node_Id) return Entity_Id is
2500 Index : Interp_Index;
2504 function Check_Right_Argument (T : Entity_Id) return Entity_Id;
2505 -- Find interpretation of right arg that has type compatible with T
2507 --------------------------
2508 -- Check_Right_Argument --
2509 --------------------------
2511 function Check_Right_Argument (T : Entity_Id) return Entity_Id is
2512 Index : Interp_Index;
2517 if not Is_Overloaded (R) then
2518 return Specific_Type (T, Etype (R));
2521 Get_First_Interp (R, Index, It);
2523 T2 := Specific_Type (T, It.Typ);
2525 if T2 /= Any_Type then
2529 Get_Next_Interp (Index, It);
2530 exit when No (It.Typ);
2535 end Check_Right_Argument;
2537 -- Start of processing for Intersect_Types
2540 if Etype (L) = Any_Type or else Etype (R) = Any_Type then
2544 if not Is_Overloaded (L) then
2545 Typ := Check_Right_Argument (Etype (L));
2549 Get_First_Interp (L, Index, It);
2550 while Present (It.Typ) loop
2551 Typ := Check_Right_Argument (It.Typ);
2552 exit when Typ /= Any_Type;
2553 Get_Next_Interp (Index, It);
2558 -- If Typ is Any_Type, it means no compatible pair of types was found
2560 if Typ = Any_Type then
2561 if Nkind (Parent (L)) in N_Op then
2562 Error_Msg_N ("incompatible types for operator", Parent (L));
2564 elsif Nkind (Parent (L)) = N_Range then
2565 Error_Msg_N ("incompatible types given in constraint", Parent (L));
2567 -- Ada 2005 (AI-251): Complete the error notification
2569 elsif Is_Class_Wide_Type (Etype (R))
2570 and then Is_Interface (Etype (Class_Wide_Type (Etype (R))))
2572 Error_Msg_NE ("(Ada 2005) does not implement interface }",
2573 L, Etype (Class_Wide_Type (Etype (R))));
2576 Error_Msg_N ("incompatible types", Parent (L));
2581 end Intersect_Types;
2583 -----------------------
2584 -- In_Generic_Actual --
2585 -----------------------
2587 function In_Generic_Actual (Exp : Node_Id) return Boolean is
2588 Par : constant Node_Id := Parent (Exp);
2594 elsif Nkind (Par) in N_Declaration then
2595 if Nkind (Par) = N_Object_Declaration then
2596 return Present (Corresponding_Generic_Association (Par));
2601 elsif Nkind (Par) = N_Object_Renaming_Declaration then
2602 return Present (Corresponding_Generic_Association (Par));
2604 elsif Nkind (Par) in N_Statement_Other_Than_Procedure_Call then
2608 return In_Generic_Actual (Parent (Par));
2610 end In_Generic_Actual;
2616 function Is_Ancestor
2619 Use_Full_View : Boolean := False) return Boolean
2626 BT1 := Base_Type (T1);
2627 BT2 := Base_Type (T2);
2629 -- Handle underlying view of records with unknown discriminants using
2630 -- the original entity that motivated the construction of this
2631 -- underlying record view (see Build_Derived_Private_Type).
2633 if Is_Underlying_Record_View (BT1) then
2634 BT1 := Underlying_Record_View (BT1);
2637 if Is_Underlying_Record_View (BT2) then
2638 BT2 := Underlying_Record_View (BT2);
2644 -- The predicate must look past privacy
2646 elsif Is_Private_Type (T1)
2647 and then Present (Full_View (T1))
2648 and then BT2 = Base_Type (Full_View (T1))
2652 elsif Is_Private_Type (T2)
2653 and then Present (Full_View (T2))
2654 and then BT1 = Base_Type (Full_View (T2))
2662 -- If there was a error on the type declaration, do not recurse
2664 if Error_Posted (Par) then
2667 elsif BT1 = Base_Type (Par)
2668 or else (Is_Private_Type (T1)
2669 and then Present (Full_View (T1))
2670 and then Base_Type (Par) = Base_Type (Full_View (T1)))
2674 elsif Is_Private_Type (Par)
2675 and then Present (Full_View (Par))
2676 and then Full_View (Par) = BT1
2680 -- Climb to the ancestor type
2682 elsif Etype (Par) /= Par then
2684 -- Use the full-view of private types (if allowed)
2687 and then Is_Private_Type (Par)
2688 and then Present (Full_View (Par))
2690 Par := Etype (Full_View (Par));
2695 -- For all other cases return False, not an Ancestor
2704 ---------------------------
2705 -- Is_Invisible_Operator --
2706 ---------------------------
2708 function Is_Invisible_Operator
2710 T : Entity_Id) return Boolean
2712 Orig_Node : constant Node_Id := Original_Node (N);
2715 if Nkind (N) not in N_Op then
2718 elsif not Comes_From_Source (N) then
2721 elsif No (Universal_Interpretation (Right_Opnd (N))) then
2724 elsif Nkind (N) in N_Binary_Op
2725 and then No (Universal_Interpretation (Left_Opnd (N)))
2730 return Is_Numeric_Type (T)
2731 and then not In_Open_Scopes (Scope (T))
2732 and then not Is_Potentially_Use_Visible (T)
2733 and then not In_Use (T)
2734 and then not In_Use (Scope (T))
2736 (Nkind (Orig_Node) /= N_Function_Call
2737 or else Nkind (Name (Orig_Node)) /= N_Expanded_Name
2738 or else Entity (Prefix (Name (Orig_Node))) /= Scope (T))
2739 and then not In_Instance;
2741 end Is_Invisible_Operator;
2743 --------------------
2745 --------------------
2747 function Is_Progenitor
2749 Typ : Entity_Id) return Boolean
2752 return Implements_Interface (Typ, Iface, Exclude_Parents => True);
2759 function Is_Subtype_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean is
2763 S := Ancestor_Subtype (T1);
2764 while Present (S) loop
2768 S := Ancestor_Subtype (S);
2779 procedure List_Interps (Nam : Node_Id; Err : Node_Id) is
2780 Index : Interp_Index;
2784 Get_First_Interp (Nam, Index, It);
2785 while Present (It.Nam) loop
2786 if Scope (It.Nam) = Standard_Standard
2787 and then Scope (It.Typ) /= Standard_Standard
2789 Error_Msg_Sloc := Sloc (Parent (It.Typ));
2790 Error_Msg_NE ("\\& (inherited) declared#!", Err, It.Nam);
2793 Error_Msg_Sloc := Sloc (It.Nam);
2794 Error_Msg_NE ("\\& declared#!", Err, It.Nam);
2797 Get_Next_Interp (Index, It);
2805 procedure New_Interps (N : Node_Id) is
2809 All_Interp.Append (No_Interp);
2811 Map_Ptr := Headers (Hash (N));
2813 if Map_Ptr = No_Entry then
2815 -- Place new node at end of table
2817 Interp_Map.Increment_Last;
2818 Headers (Hash (N)) := Interp_Map.Last;
2821 -- Place node at end of chain, or locate its previous entry
2824 if Interp_Map.Table (Map_Ptr).Node = N then
2826 -- Node is already in the table, and is being rewritten.
2827 -- Start a new interp section, retain hash link.
2829 Interp_Map.Table (Map_Ptr).Node := N;
2830 Interp_Map.Table (Map_Ptr).Index := All_Interp.Last;
2831 Set_Is_Overloaded (N, True);
2835 exit when Interp_Map.Table (Map_Ptr).Next = No_Entry;
2836 Map_Ptr := Interp_Map.Table (Map_Ptr).Next;
2840 -- Chain the new node
2842 Interp_Map.Increment_Last;
2843 Interp_Map.Table (Map_Ptr).Next := Interp_Map.Last;
2846 Interp_Map.Table (Interp_Map.Last) := (N, All_Interp.Last, No_Entry);
2847 Set_Is_Overloaded (N, True);
2850 ---------------------------
2851 -- Operator_Matches_Spec --
2852 ---------------------------
2854 function Operator_Matches_Spec (Op, New_S : Entity_Id) return Boolean is
2855 Op_Name : constant Name_Id := Chars (Op);
2856 T : constant Entity_Id := Etype (New_S);
2864 -- To verify that a predefined operator matches a given signature,
2865 -- do a case analysis of the operator classes. Function can have one
2866 -- or two formals and must have the proper result type.
2868 New_F := First_Formal (New_S);
2869 Old_F := First_Formal (Op);
2871 while Present (New_F) and then Present (Old_F) loop
2873 Next_Formal (New_F);
2874 Next_Formal (Old_F);
2877 -- Definite mismatch if different number of parameters
2879 if Present (Old_F) or else Present (New_F) then
2885 T1 := Etype (First_Formal (New_S));
2887 if Op_Name = Name_Op_Subtract
2888 or else Op_Name = Name_Op_Add
2889 or else Op_Name = Name_Op_Abs
2891 return Base_Type (T1) = Base_Type (T)
2892 and then Is_Numeric_Type (T);
2894 elsif Op_Name = Name_Op_Not then
2895 return Base_Type (T1) = Base_Type (T)
2896 and then Valid_Boolean_Arg (Base_Type (T));
2905 T1 := Etype (First_Formal (New_S));
2906 T2 := Etype (Next_Formal (First_Formal (New_S)));
2908 if Op_Name = Name_Op_And or else Op_Name = Name_Op_Or
2909 or else Op_Name = Name_Op_Xor
2911 return Base_Type (T1) = Base_Type (T2)
2912 and then Base_Type (T1) = Base_Type (T)
2913 and then Valid_Boolean_Arg (Base_Type (T));
2915 elsif Op_Name = Name_Op_Eq or else Op_Name = Name_Op_Ne then
2916 return Base_Type (T1) = Base_Type (T2)
2917 and then not Is_Limited_Type (T1)
2918 and then Is_Boolean_Type (T);
2920 elsif Op_Name = Name_Op_Lt or else Op_Name = Name_Op_Le
2921 or else Op_Name = Name_Op_Gt or else Op_Name = Name_Op_Ge
2923 return Base_Type (T1) = Base_Type (T2)
2924 and then Valid_Comparison_Arg (T1)
2925 and then Is_Boolean_Type (T);
2927 elsif Op_Name = Name_Op_Add or else Op_Name = Name_Op_Subtract then
2928 return Base_Type (T1) = Base_Type (T2)
2929 and then Base_Type (T1) = Base_Type (T)
2930 and then Is_Numeric_Type (T);
2932 -- For division and multiplication, a user-defined function does not
2933 -- match the predefined universal_fixed operation, except in Ada 83.
2935 elsif Op_Name = Name_Op_Divide then
2936 return (Base_Type (T1) = Base_Type (T2)
2937 and then Base_Type (T1) = Base_Type (T)
2938 and then Is_Numeric_Type (T)
2939 and then (not Is_Fixed_Point_Type (T)
2940 or else Ada_Version = Ada_83))
2942 -- Mixed_Mode operations on fixed-point types
2944 or else (Base_Type (T1) = Base_Type (T)
2945 and then Base_Type (T2) = Base_Type (Standard_Integer)
2946 and then Is_Fixed_Point_Type (T))
2948 -- A user defined operator can also match (and hide) a mixed
2949 -- operation on universal literals.
2951 or else (Is_Integer_Type (T2)
2952 and then Is_Floating_Point_Type (T1)
2953 and then Base_Type (T1) = Base_Type (T));
2955 elsif Op_Name = Name_Op_Multiply then
2956 return (Base_Type (T1) = Base_Type (T2)
2957 and then Base_Type (T1) = Base_Type (T)
2958 and then Is_Numeric_Type (T)
2959 and then (not Is_Fixed_Point_Type (T)
2960 or else Ada_Version = Ada_83))
2962 -- Mixed_Mode operations on fixed-point types
2964 or else (Base_Type (T1) = Base_Type (T)
2965 and then Base_Type (T2) = Base_Type (Standard_Integer)
2966 and then Is_Fixed_Point_Type (T))
2968 or else (Base_Type (T2) = Base_Type (T)
2969 and then Base_Type (T1) = Base_Type (Standard_Integer)
2970 and then Is_Fixed_Point_Type (T))
2972 or else (Is_Integer_Type (T2)
2973 and then Is_Floating_Point_Type (T1)
2974 and then Base_Type (T1) = Base_Type (T))
2976 or else (Is_Integer_Type (T1)
2977 and then Is_Floating_Point_Type (T2)
2978 and then Base_Type (T2) = Base_Type (T));
2980 elsif Op_Name = Name_Op_Mod or else Op_Name = Name_Op_Rem then
2981 return Base_Type (T1) = Base_Type (T2)
2982 and then Base_Type (T1) = Base_Type (T)
2983 and then Is_Integer_Type (T);
2985 elsif Op_Name = Name_Op_Expon then
2986 return Base_Type (T1) = Base_Type (T)
2987 and then Is_Numeric_Type (T)
2988 and then Base_Type (T2) = Base_Type (Standard_Integer);
2990 elsif Op_Name = Name_Op_Concat then
2991 return Is_Array_Type (T)
2992 and then (Base_Type (T) = Base_Type (Etype (Op)))
2993 and then (Base_Type (T1) = Base_Type (T)
2995 Base_Type (T1) = Base_Type (Component_Type (T)))
2996 and then (Base_Type (T2) = Base_Type (T)
2998 Base_Type (T2) = Base_Type (Component_Type (T)));
3004 end Operator_Matches_Spec;
3010 procedure Remove_Interp (I : in out Interp_Index) is
3014 -- Find end of interp list and copy downward to erase the discarded one
3017 while Present (All_Interp.Table (II).Typ) loop
3021 for J in I + 1 .. II loop
3022 All_Interp.Table (J - 1) := All_Interp.Table (J);
3025 -- Back up interp index to insure that iterator will pick up next
3026 -- available interpretation.
3035 procedure Save_Interps (Old_N : Node_Id; New_N : Node_Id) is
3037 O_N : Node_Id := Old_N;
3040 if Is_Overloaded (Old_N) then
3041 if Nkind (Old_N) = N_Selected_Component
3042 and then Is_Overloaded (Selector_Name (Old_N))
3044 O_N := Selector_Name (Old_N);
3047 Map_Ptr := Headers (Hash (O_N));
3049 while Interp_Map.Table (Map_Ptr).Node /= O_N loop
3050 Map_Ptr := Interp_Map.Table (Map_Ptr).Next;
3051 pragma Assert (Map_Ptr /= No_Entry);
3054 New_Interps (New_N);
3055 Interp_Map.Table (Interp_Map.Last).Index :=
3056 Interp_Map.Table (Map_Ptr).Index;
3064 function Specific_Type (Typ_1, Typ_2 : Entity_Id) return Entity_Id is
3065 T1 : constant Entity_Id := Available_View (Typ_1);
3066 T2 : constant Entity_Id := Available_View (Typ_2);
3067 B1 : constant Entity_Id := Base_Type (T1);
3068 B2 : constant Entity_Id := Base_Type (T2);
3070 function Is_Remote_Access (T : Entity_Id) return Boolean;
3071 -- Check whether T is the equivalent type of a remote access type.
3072 -- If distribution is enabled, T is a legal context for Null.
3074 ----------------------
3075 -- Is_Remote_Access --
3076 ----------------------
3078 function Is_Remote_Access (T : Entity_Id) return Boolean is
3080 return Is_Record_Type (T)
3081 and then (Is_Remote_Call_Interface (T)
3082 or else Is_Remote_Types (T))
3083 and then Present (Corresponding_Remote_Type (T))
3084 and then Is_Access_Type (Corresponding_Remote_Type (T));
3085 end Is_Remote_Access;
3087 -- Start of processing for Specific_Type
3090 if T1 = Any_Type or else T2 = Any_Type then
3097 elsif (T1 = Universal_Integer and then Is_Integer_Type (T2))
3098 or else (T1 = Universal_Real and then Is_Real_Type (T2))
3099 or else (T1 = Universal_Fixed and then Is_Fixed_Point_Type (T2))
3100 or else (T1 = Any_Fixed and then Is_Fixed_Point_Type (T2))
3104 elsif (T2 = Universal_Integer and then Is_Integer_Type (T1))
3105 or else (T2 = Universal_Real and then Is_Real_Type (T1))
3106 or else (T2 = Universal_Fixed and then Is_Fixed_Point_Type (T1))
3107 or else (T2 = Any_Fixed and then Is_Fixed_Point_Type (T1))
3111 elsif T2 = Any_String and then Is_String_Type (T1) then
3114 elsif T1 = Any_String and then Is_String_Type (T2) then
3117 elsif T2 = Any_Character and then Is_Character_Type (T1) then
3120 elsif T1 = Any_Character and then Is_Character_Type (T2) then
3123 elsif T1 = Any_Access
3124 and then (Is_Access_Type (T2) or else Is_Remote_Access (T2))
3128 elsif T2 = Any_Access
3129 and then (Is_Access_Type (T1) or else Is_Remote_Access (T1))
3133 elsif T2 = Any_Composite
3134 and then Is_Aggregate_Type (T1)
3138 elsif T1 = Any_Composite
3139 and then Is_Aggregate_Type (T2)
3143 elsif T1 = Any_Modular and then Is_Modular_Integer_Type (T2) then
3146 elsif T2 = Any_Modular and then Is_Modular_Integer_Type (T1) then
3149 -- ----------------------------------------------------------
3150 -- Special cases for equality operators (all other predefined
3151 -- operators can never apply to tagged types)
3152 -- ----------------------------------------------------------
3154 -- Ada 2005 (AI-251): T1 and T2 are class-wide types, and T2 is an
3157 elsif Is_Class_Wide_Type (T1)
3158 and then Is_Class_Wide_Type (T2)
3159 and then Is_Interface (Etype (T2))
3163 -- Ada 2005 (AI-251): T1 is a concrete type that implements the
3164 -- class-wide interface T2
3166 elsif Is_Class_Wide_Type (T2)
3167 and then Is_Interface (Etype (T2))
3168 and then Interface_Present_In_Ancestor (Typ => T1,
3169 Iface => Etype (T2))
3173 elsif Is_Class_Wide_Type (T1)
3174 and then Is_Ancestor (Root_Type (T1), T2)
3178 elsif Is_Class_Wide_Type (T2)
3179 and then Is_Ancestor (Root_Type (T2), T1)
3183 elsif (Ekind (B1) = E_Access_Subprogram_Type
3185 Ekind (B1) = E_Access_Protected_Subprogram_Type)
3186 and then Ekind (Designated_Type (B1)) /= E_Subprogram_Type
3187 and then Is_Access_Type (T2)
3191 elsif (Ekind (B2) = E_Access_Subprogram_Type
3193 Ekind (B2) = E_Access_Protected_Subprogram_Type)
3194 and then Ekind (Designated_Type (B2)) /= E_Subprogram_Type
3195 and then Is_Access_Type (T1)
3199 elsif (Ekind (T1) = E_Allocator_Type
3200 or else Ekind (T1) = E_Access_Attribute_Type
3201 or else Ekind (T1) = E_Anonymous_Access_Type)
3202 and then Is_Access_Type (T2)
3206 elsif (Ekind (T2) = E_Allocator_Type
3207 or else Ekind (T2) = E_Access_Attribute_Type
3208 or else Ekind (T2) = E_Anonymous_Access_Type)
3209 and then Is_Access_Type (T1)
3213 -- If none of the above cases applies, types are not compatible
3220 ---------------------
3221 -- Set_Abstract_Op --
3222 ---------------------
3224 procedure Set_Abstract_Op (I : Interp_Index; V : Entity_Id) is
3226 All_Interp.Table (I).Abstract_Op := V;
3227 end Set_Abstract_Op;
3229 -----------------------
3230 -- Valid_Boolean_Arg --
3231 -----------------------
3233 -- In addition to booleans and arrays of booleans, we must include
3234 -- aggregates as valid boolean arguments, because in the first pass of
3235 -- resolution their components are not examined. If it turns out not to be
3236 -- an aggregate of booleans, this will be diagnosed in Resolve.
3237 -- Any_Composite must be checked for prior to the array type checks because
3238 -- Any_Composite does not have any associated indexes.
3240 function Valid_Boolean_Arg (T : Entity_Id) return Boolean is
3242 return Is_Boolean_Type (T)
3243 or else T = Any_Composite
3244 or else (Is_Array_Type (T)
3245 and then T /= Any_String
3246 and then Number_Dimensions (T) = 1
3247 and then Is_Boolean_Type (Component_Type (T))
3248 and then (not Is_Private_Composite (T)
3249 or else In_Instance)
3250 and then (not Is_Limited_Composite (T)
3251 or else In_Instance))
3252 or else Is_Modular_Integer_Type (T)
3253 or else T = Universal_Integer;
3254 end Valid_Boolean_Arg;
3256 --------------------------
3257 -- Valid_Comparison_Arg --
3258 --------------------------
3260 function Valid_Comparison_Arg (T : Entity_Id) return Boolean is
3263 if T = Any_Composite then
3265 elsif Is_Discrete_Type (T)
3266 or else Is_Real_Type (T)
3269 elsif Is_Array_Type (T)
3270 and then Number_Dimensions (T) = 1
3271 and then Is_Discrete_Type (Component_Type (T))
3272 and then (not Is_Private_Composite (T)
3273 or else In_Instance)
3274 and then (not Is_Limited_Composite (T)
3275 or else In_Instance)
3278 elsif Is_String_Type (T) then
3283 end Valid_Comparison_Arg;
3285 ----------------------
3286 -- Write_Interp_Ref --
3287 ----------------------
3289 procedure Write_Interp_Ref (Map_Ptr : Int) is
3291 Write_Str (" Node: ");
3292 Write_Int (Int (Interp_Map.Table (Map_Ptr).Node));
3293 Write_Str (" Index: ");
3294 Write_Int (Int (Interp_Map.Table (Map_Ptr).Index));
3295 Write_Str (" Next: ");
3296 Write_Int (Interp_Map.Table (Map_Ptr).Next);
3298 end Write_Interp_Ref;
3300 ---------------------
3301 -- Write_Overloads --
3302 ---------------------
3304 procedure Write_Overloads (N : Node_Id) is
3310 if not Is_Overloaded (N) then
3311 Write_Str ("Non-overloaded entity ");
3313 Write_Entity_Info (Entity (N), " ");
3316 Get_First_Interp (N, I, It);
3317 Write_Str ("Overloaded entity ");
3319 Write_Str (" Name Type Abstract Op");
3321 Write_Str ("===============================================");
3325 while Present (Nam) loop
3326 Write_Int (Int (Nam));
3328 Write_Name (Chars (Nam));
3330 Write_Int (Int (It.Typ));
3332 Write_Name (Chars (It.Typ));
3334 if Present (It.Abstract_Op) then
3336 Write_Int (Int (It.Abstract_Op));
3338 Write_Name (Chars (It.Abstract_Op));
3342 Get_Next_Interp (I, It);
3346 end Write_Overloads;