1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2019, 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;
27 with Checks; use Checks;
28 with Debug; use Debug;
29 with Debug_A; use Debug_A;
30 with Einfo; use Einfo;
31 with Errout; use Errout;
32 with Expander; use Expander;
33 with Exp_Ch6; use Exp_Ch6;
34 with Exp_Ch7; use Exp_Ch7;
35 with Exp_Disp; use Exp_Disp;
36 with Exp_Tss; use Exp_Tss;
37 with Exp_Util; use Exp_Util;
38 with Freeze; use Freeze;
39 with Ghost; use Ghost;
40 with Inline; use Inline;
41 with Itypes; use Itypes;
43 with Lib.Xref; use Lib.Xref;
44 with Namet; use Namet;
45 with Nmake; use Nmake;
46 with Nlists; use Nlists;
48 with Output; use Output;
49 with Par_SCO; use Par_SCO;
50 with Restrict; use Restrict;
51 with Rident; use Rident;
52 with Rtsfind; use Rtsfind;
54 with Sem_Aggr; use Sem_Aggr;
55 with Sem_Attr; use Sem_Attr;
56 with Sem_Aux; use Sem_Aux;
57 with Sem_Cat; use Sem_Cat;
58 with Sem_Ch3; use Sem_Ch3;
59 with Sem_Ch4; use Sem_Ch4;
60 with Sem_Ch6; use Sem_Ch6;
61 with Sem_Ch8; use Sem_Ch8;
62 with Sem_Ch13; use Sem_Ch13;
63 with Sem_Dim; use Sem_Dim;
64 with Sem_Disp; use Sem_Disp;
65 with Sem_Dist; use Sem_Dist;
66 with Sem_Elab; use Sem_Elab;
67 with Sem_Elim; use Sem_Elim;
68 with Sem_Eval; use Sem_Eval;
69 with Sem_Intr; use Sem_Intr;
70 with Sem_Mech; use Sem_Mech;
71 with Sem_Type; use Sem_Type;
72 with Sem_Util; use Sem_Util;
73 with Sem_Warn; use Sem_Warn;
74 with Sinfo; use Sinfo;
75 with Sinfo.CN; use Sinfo.CN;
76 with Snames; use Snames;
77 with Stand; use Stand;
78 with Stringt; use Stringt;
79 with Style; use Style;
80 with Targparm; use Targparm;
81 with Tbuild; use Tbuild;
82 with Uintp; use Uintp;
83 with Urealp; use Urealp;
85 package body Sem_Res is
87 -----------------------
88 -- Local Subprograms --
89 -----------------------
91 -- Second pass (top-down) type checking and overload resolution procedures
92 -- Typ is the type required by context. These procedures propagate the
93 -- type information recursively to the descendants of N. If the node is not
94 -- overloaded, its Etype is established in the first pass. If overloaded,
95 -- the Resolve routines set the correct type. For arithmetic operators, the
96 -- Etype is the base type of the context.
98 -- Note that Resolve_Attribute is separated off in Sem_Attr
100 procedure Check_Discriminant_Use (N : Node_Id);
101 -- Enforce the restrictions on the use of discriminants when constraining
102 -- a component of a discriminated type (record or concurrent type).
104 procedure Check_For_Visible_Operator (N : Node_Id; T : Entity_Id);
105 -- Given a node for an operator associated with type T, check that the
106 -- operator is visible. Operators all of whose operands are universal must
107 -- be checked for visibility during resolution because their type is not
108 -- determinable based on their operands.
110 procedure Check_Fully_Declared_Prefix
113 -- Check that the type of the prefix of a dereference is not incomplete
115 function Check_Infinite_Recursion (Call : Node_Id) return Boolean;
116 -- Given a call node, Call, which is known to occur immediately within the
117 -- subprogram being called, determines whether it is a detectable case of
118 -- an infinite recursion, and if so, outputs appropriate messages. Returns
119 -- True if an infinite recursion is detected, and False otherwise.
121 procedure Check_No_Direct_Boolean_Operators (N : Node_Id);
122 -- N is the node for a logical operator. If the operator is predefined, and
123 -- the root type of the operands is Standard.Boolean, then a check is made
124 -- for restriction No_Direct_Boolean_Operators. This procedure also handles
125 -- the style check for Style_Check_Boolean_And_Or.
127 function Is_Atomic_Ref_With_Address (N : Node_Id) return Boolean;
128 -- N is either an indexed component or a selected component. This function
129 -- returns true if the prefix refers to an object that has an address
130 -- clause (the case in which we may want to issue a warning).
132 function Is_Definite_Access_Type (E : Entity_Id) return Boolean;
133 -- Determine whether E is an access type declared by an access declaration,
134 -- and not an (anonymous) allocator type.
136 function Is_Predefined_Op (Nam : Entity_Id) return Boolean;
137 -- Utility to check whether the entity for an operator is a predefined
138 -- operator, in which case the expression is left as an operator in the
139 -- tree (else it is rewritten into a call). An instance of an intrinsic
140 -- conversion operation may be given an operator name, but is not treated
141 -- like an operator. Note that an operator that is an imported back-end
142 -- builtin has convention Intrinsic, but is expected to be rewritten into
143 -- a call, so such an operator is not treated as predefined by this
146 procedure Preanalyze_And_Resolve
149 With_Freezing : Boolean);
150 -- Subsidiary of public versions of Preanalyze_And_Resolve.
152 procedure Replace_Actual_Discriminants (N : Node_Id; Default : Node_Id);
153 -- If a default expression in entry call N depends on the discriminants
154 -- of the task, it must be replaced with a reference to the discriminant
155 -- of the task being called.
157 procedure Resolve_Op_Concat_Arg
162 -- Internal procedure for Resolve_Op_Concat to resolve one operand of
163 -- concatenation operator. The operand is either of the array type or of
164 -- the component type. If the operand is an aggregate, and the component
165 -- type is composite, this is ambiguous if component type has aggregates.
167 procedure Resolve_Op_Concat_First (N : Node_Id; Typ : Entity_Id);
168 -- Does the first part of the work of Resolve_Op_Concat
170 procedure Resolve_Op_Concat_Rest (N : Node_Id; Typ : Entity_Id);
171 -- Does the "rest" of the work of Resolve_Op_Concat, after the left operand
172 -- has been resolved. See Resolve_Op_Concat for details.
174 procedure Resolve_Allocator (N : Node_Id; Typ : Entity_Id);
175 procedure Resolve_Arithmetic_Op (N : Node_Id; Typ : Entity_Id);
176 procedure Resolve_Call (N : Node_Id; Typ : Entity_Id);
177 procedure Resolve_Case_Expression (N : Node_Id; Typ : Entity_Id);
178 procedure Resolve_Character_Literal (N : Node_Id; Typ : Entity_Id);
179 procedure Resolve_Comparison_Op (N : Node_Id; Typ : Entity_Id);
180 procedure Resolve_Entity_Name (N : Node_Id; Typ : Entity_Id);
181 procedure Resolve_Equality_Op (N : Node_Id; Typ : Entity_Id);
182 procedure Resolve_Explicit_Dereference (N : Node_Id; Typ : Entity_Id);
183 procedure Resolve_Expression_With_Actions (N : Node_Id; Typ : Entity_Id);
184 procedure Resolve_If_Expression (N : Node_Id; Typ : Entity_Id);
185 procedure Resolve_Generalized_Indexing (N : Node_Id; Typ : Entity_Id);
186 procedure Resolve_Indexed_Component (N : Node_Id; Typ : Entity_Id);
187 procedure Resolve_Integer_Literal (N : Node_Id; Typ : Entity_Id);
188 procedure Resolve_Logical_Op (N : Node_Id; Typ : Entity_Id);
189 procedure Resolve_Membership_Op (N : Node_Id; Typ : Entity_Id);
190 procedure Resolve_Null (N : Node_Id; Typ : Entity_Id);
191 procedure Resolve_Operator_Symbol (N : Node_Id; Typ : Entity_Id);
192 procedure Resolve_Op_Concat (N : Node_Id; Typ : Entity_Id);
193 procedure Resolve_Op_Expon (N : Node_Id; Typ : Entity_Id);
194 procedure Resolve_Op_Not (N : Node_Id; Typ : Entity_Id);
195 procedure Resolve_Qualified_Expression (N : Node_Id; Typ : Entity_Id);
196 procedure Resolve_Raise_Expression (N : Node_Id; Typ : Entity_Id);
197 procedure Resolve_Range (N : Node_Id; Typ : Entity_Id);
198 procedure Resolve_Real_Literal (N : Node_Id; Typ : Entity_Id);
199 procedure Resolve_Reference (N : Node_Id; Typ : Entity_Id);
200 procedure Resolve_Selected_Component (N : Node_Id; Typ : Entity_Id);
201 procedure Resolve_Shift (N : Node_Id; Typ : Entity_Id);
202 procedure Resolve_Short_Circuit (N : Node_Id; Typ : Entity_Id);
203 procedure Resolve_Slice (N : Node_Id; Typ : Entity_Id);
204 procedure Resolve_String_Literal (N : Node_Id; Typ : Entity_Id);
205 procedure Resolve_Target_Name (N : Node_Id; Typ : Entity_Id);
206 procedure Resolve_Type_Conversion (N : Node_Id; Typ : Entity_Id);
207 procedure Resolve_Unary_Op (N : Node_Id; Typ : Entity_Id);
208 procedure Resolve_Unchecked_Expression (N : Node_Id; Typ : Entity_Id);
209 procedure Resolve_Unchecked_Type_Conversion (N : Node_Id; Typ : Entity_Id);
211 function Operator_Kind
213 Is_Binary : Boolean) return Node_Kind;
214 -- Utility to map the name of an operator into the corresponding Node. Used
215 -- by other node rewriting procedures.
217 procedure Resolve_Actuals (N : Node_Id; Nam : Entity_Id);
218 -- Resolve actuals of call, and add default expressions for missing ones.
219 -- N is the Node_Id for the subprogram call, and Nam is the entity of the
220 -- called subprogram.
222 procedure Resolve_Entry_Call (N : Node_Id; Typ : Entity_Id);
223 -- Called from Resolve_Call, when the prefix denotes an entry or element
224 -- of entry family. Actuals are resolved as for subprograms, and the node
225 -- is rebuilt as an entry call. Also called for protected operations. Typ
226 -- is the context type, which is used when the operation is a protected
227 -- function with no arguments, and the return value is indexed.
229 procedure Resolve_Intrinsic_Operator (N : Node_Id; Typ : Entity_Id);
230 -- A call to a user-defined intrinsic operator is rewritten as a call to
231 -- the corresponding predefined operator, with suitable conversions. Note
232 -- that this applies only for intrinsic operators that denote predefined
233 -- operators, not ones that are intrinsic imports of back-end builtins.
235 procedure Resolve_Intrinsic_Unary_Operator (N : Node_Id; Typ : Entity_Id);
236 -- Ditto, for arithmetic unary operators
238 procedure Rewrite_Operator_As_Call (N : Node_Id; Nam : Entity_Id);
239 -- If an operator node resolves to a call to a user-defined operator,
240 -- rewrite the node as a function call.
242 procedure Make_Call_Into_Operator
246 -- Inverse transformation: if an operator is given in functional notation,
247 -- then after resolving the node, transform into an operator node, so that
248 -- operands are resolved properly. Recall that predefined operators do not
249 -- have a full signature and special resolution rules apply.
251 procedure Rewrite_Renamed_Operator
255 -- An operator can rename another, e.g. in an instantiation. In that
256 -- case, the proper operator node must be constructed and resolved.
258 procedure Set_String_Literal_Subtype (N : Node_Id; Typ : Entity_Id);
259 -- The String_Literal_Subtype is built for all strings that are not
260 -- operands of a static concatenation operation. If the argument is not
261 -- a N_String_Literal node, then the call has no effect.
263 procedure Set_Slice_Subtype (N : Node_Id);
264 -- Build subtype of array type, with the range specified by the slice
266 procedure Simplify_Type_Conversion (N : Node_Id);
267 -- Called after N has been resolved and evaluated, but before range checks
268 -- have been applied. Currently simplifies a combination of floating-point
269 -- to integer conversion and Rounding or Truncation attribute.
271 function Unique_Fixed_Point_Type (N : Node_Id) return Entity_Id;
272 -- A universal_fixed expression in an universal context is unambiguous if
273 -- there is only one applicable fixed point type. Determining whether there
274 -- is only one requires a search over all visible entities, and happens
275 -- only in very pathological cases (see 6115-006).
277 -------------------------
278 -- Ambiguous_Character --
279 -------------------------
281 procedure Ambiguous_Character (C : Node_Id) is
285 if Nkind (C) = N_Character_Literal then
286 Error_Msg_N ("ambiguous character literal", C);
288 -- First the ones in Standard
290 Error_Msg_N ("\\possible interpretation: Character!", C);
291 Error_Msg_N ("\\possible interpretation: Wide_Character!", C);
293 -- Include Wide_Wide_Character in Ada 2005 mode
295 if Ada_Version >= Ada_2005 then
296 Error_Msg_N ("\\possible interpretation: Wide_Wide_Character!", C);
299 -- Now any other types that match
301 E := Current_Entity (C);
302 while Present (E) loop
303 Error_Msg_NE ("\\possible interpretation:}!", C, Etype (E));
307 end Ambiguous_Character;
309 -------------------------
310 -- Analyze_And_Resolve --
311 -------------------------
313 procedure Analyze_And_Resolve (N : Node_Id) is
317 end Analyze_And_Resolve;
319 procedure Analyze_And_Resolve (N : Node_Id; Typ : Entity_Id) is
323 end Analyze_And_Resolve;
325 -- Versions with check(s) suppressed
327 procedure Analyze_And_Resolve
332 Scop : constant Entity_Id := Current_Scope;
335 if Suppress = All_Checks then
337 Sva : constant Suppress_Array := Scope_Suppress.Suppress;
339 Scope_Suppress.Suppress := (others => True);
340 Analyze_And_Resolve (N, Typ);
341 Scope_Suppress.Suppress := Sva;
346 Svg : constant Boolean := Scope_Suppress.Suppress (Suppress);
348 Scope_Suppress.Suppress (Suppress) := True;
349 Analyze_And_Resolve (N, Typ);
350 Scope_Suppress.Suppress (Suppress) := Svg;
354 if Current_Scope /= Scop
355 and then Scope_Is_Transient
357 -- This can only happen if a transient scope was created for an inner
358 -- expression, which will be removed upon completion of the analysis
359 -- of an enclosing construct. The transient scope must have the
360 -- suppress status of the enclosing environment, not of this Analyze
363 Scope_Stack.Table (Scope_Stack.Last).Save_Scope_Suppress :=
366 end Analyze_And_Resolve;
368 procedure Analyze_And_Resolve
372 Scop : constant Entity_Id := Current_Scope;
375 if Suppress = All_Checks then
377 Sva : constant Suppress_Array := Scope_Suppress.Suppress;
379 Scope_Suppress.Suppress := (others => True);
380 Analyze_And_Resolve (N);
381 Scope_Suppress.Suppress := Sva;
386 Svg : constant Boolean := Scope_Suppress.Suppress (Suppress);
388 Scope_Suppress.Suppress (Suppress) := True;
389 Analyze_And_Resolve (N);
390 Scope_Suppress.Suppress (Suppress) := Svg;
394 if Current_Scope /= Scop and then Scope_Is_Transient then
395 Scope_Stack.Table (Scope_Stack.Last).Save_Scope_Suppress :=
398 end Analyze_And_Resolve;
400 ----------------------------
401 -- Check_Discriminant_Use --
402 ----------------------------
404 procedure Check_Discriminant_Use (N : Node_Id) is
405 PN : constant Node_Id := Parent (N);
406 Disc : constant Entity_Id := Entity (N);
411 -- Any use in a spec-expression is legal
413 if In_Spec_Expression then
416 elsif Nkind (PN) = N_Range then
418 -- Discriminant cannot be used to constrain a scalar type
422 if Nkind (P) = N_Range_Constraint
423 and then Nkind (Parent (P)) = N_Subtype_Indication
424 and then Nkind (Parent (Parent (P))) = N_Component_Definition
426 Error_Msg_N ("discriminant cannot constrain scalar type", N);
428 elsif Nkind (P) = N_Index_Or_Discriminant_Constraint then
430 -- The following check catches the unusual case where a
431 -- discriminant appears within an index constraint that is part
432 -- of a larger expression within a constraint on a component,
433 -- e.g. "C : Int range 1 .. F (new A(1 .. D))". For now we only
434 -- check case of record components, and note that a similar check
435 -- should also apply in the case of discriminant constraints
438 -- Note that the check for N_Subtype_Declaration below is to
439 -- detect the valid use of discriminants in the constraints of a
440 -- subtype declaration when this subtype declaration appears
441 -- inside the scope of a record type (which is syntactically
442 -- illegal, but which may be created as part of derived type
443 -- processing for records). See Sem_Ch3.Build_Derived_Record_Type
446 if Ekind (Current_Scope) = E_Record_Type
447 and then Scope (Disc) = Current_Scope
449 (Nkind (Parent (P)) = N_Subtype_Indication
451 Nkind_In (Parent (Parent (P)), N_Component_Definition,
452 N_Subtype_Declaration)
453 and then Paren_Count (N) = 0)
456 ("discriminant must appear alone in component constraint", N);
460 -- Detect a common error:
462 -- type R (D : Positive := 100) is record
463 -- Name : String (1 .. D);
466 -- The default value causes an object of type R to be allocated
467 -- with room for Positive'Last characters. The RM does not mandate
468 -- the allocation of the maximum size, but that is what GNAT does
469 -- so we should warn the programmer that there is a problem.
471 Check_Large : declare
477 function Large_Storage_Type (T : Entity_Id) return Boolean;
478 -- Return True if type T has a large enough range that any
479 -- array whose index type covered the whole range of the type
480 -- would likely raise Storage_Error.
482 ------------------------
483 -- Large_Storage_Type --
484 ------------------------
486 function Large_Storage_Type (T : Entity_Id) return Boolean is
488 -- The type is considered large if its bounds are known at
489 -- compile time and if it requires at least as many bits as
490 -- a Positive to store the possible values.
492 return Compile_Time_Known_Value (Type_Low_Bound (T))
493 and then Compile_Time_Known_Value (Type_High_Bound (T))
495 Minimum_Size (T, Biased => True) >=
496 RM_Size (Standard_Positive);
497 end Large_Storage_Type;
499 -- Start of processing for Check_Large
502 -- Check that the Disc has a large range
504 if not Large_Storage_Type (Etype (Disc)) then
508 -- If the enclosing type is limited, we allocate only the
509 -- default value, not the maximum, and there is no need for
512 if Is_Limited_Type (Scope (Disc)) then
516 -- Check that it is the high bound
518 if N /= High_Bound (PN)
519 or else No (Discriminant_Default_Value (Disc))
524 -- Check the array allows a large range at this bound. First
529 if Nkind (SI) /= N_Subtype_Indication then
533 T := Entity (Subtype_Mark (SI));
535 if not Is_Array_Type (T) then
539 -- Next, find the dimension
541 TB := First_Index (T);
542 CB := First (Constraints (P));
544 and then Present (TB)
545 and then Present (CB)
556 -- Now, check the dimension has a large range
558 if not Large_Storage_Type (Etype (TB)) then
562 -- Warn about the danger
565 ("??creation of & object may raise Storage_Error!",
574 -- Legal case is in index or discriminant constraint
576 elsif Nkind_In (PN, N_Index_Or_Discriminant_Constraint,
577 N_Discriminant_Association)
579 if Paren_Count (N) > 0 then
581 ("discriminant in constraint must appear alone", N);
583 elsif Nkind (N) = N_Expanded_Name
584 and then Comes_From_Source (N)
587 ("discriminant must appear alone as a direct name", N);
592 -- Otherwise, context is an expression. It should not be within (i.e. a
593 -- subexpression of) a constraint for a component.
598 while not Nkind_In (P, N_Component_Declaration,
599 N_Subtype_Indication,
607 -- If the discriminant is used in an expression that is a bound of a
608 -- scalar type, an Itype is created and the bounds are attached to
609 -- its range, not to the original subtype indication. Such use is of
610 -- course a double fault.
612 if (Nkind (P) = N_Subtype_Indication
613 and then Nkind_In (Parent (P), N_Component_Definition,
614 N_Derived_Type_Definition)
615 and then D = Constraint (P))
617 -- The constraint itself may be given by a subtype indication,
618 -- rather than by a more common discrete range.
620 or else (Nkind (P) = N_Subtype_Indication
622 Nkind (Parent (P)) = N_Index_Or_Discriminant_Constraint)
623 or else Nkind (P) = N_Entry_Declaration
624 or else Nkind (D) = N_Defining_Identifier
627 ("discriminant in constraint must appear alone", N);
630 end Check_Discriminant_Use;
632 --------------------------------
633 -- Check_For_Visible_Operator --
634 --------------------------------
636 procedure Check_For_Visible_Operator (N : Node_Id; T : Entity_Id) is
638 if Is_Invisible_Operator (N, T) then
639 Error_Msg_NE -- CODEFIX
640 ("operator for} is not directly visible!", N, First_Subtype (T));
641 Error_Msg_N -- CODEFIX
642 ("use clause would make operation legal!", N);
644 end Check_For_Visible_Operator;
646 ----------------------------------
647 -- Check_Fully_Declared_Prefix --
648 ----------------------------------
650 procedure Check_Fully_Declared_Prefix
655 -- Check that the designated type of the prefix of a dereference is
656 -- not an incomplete type. This cannot be done unconditionally, because
657 -- dereferences of private types are legal in default expressions. This
658 -- case is taken care of in Check_Fully_Declared, called below. There
659 -- are also 2005 cases where it is legal for the prefix to be unfrozen.
661 -- This consideration also applies to similar checks for allocators,
662 -- qualified expressions, and type conversions.
664 -- An additional exception concerns other per-object expressions that
665 -- are not directly related to component declarations, in particular
666 -- representation pragmas for tasks. These will be per-object
667 -- expressions if they depend on discriminants or some global entity.
668 -- If the task has access discriminants, the designated type may be
669 -- incomplete at the point the expression is resolved. This resolution
670 -- takes place within the body of the initialization procedure, where
671 -- the discriminant is replaced by its discriminal.
673 if Is_Entity_Name (Pref)
674 and then Ekind (Entity (Pref)) = E_In_Parameter
678 -- Ada 2005 (AI-326): Tagged incomplete types allowed. The wrong usages
679 -- are handled by Analyze_Access_Attribute, Analyze_Assignment,
680 -- Analyze_Object_Renaming, and Freeze_Entity.
682 elsif Ada_Version >= Ada_2005
683 and then Is_Entity_Name (Pref)
684 and then Is_Access_Type (Etype (Pref))
685 and then Ekind (Directly_Designated_Type (Etype (Pref))) =
687 and then Is_Tagged_Type (Directly_Designated_Type (Etype (Pref)))
691 Check_Fully_Declared (Typ, Parent (Pref));
693 end Check_Fully_Declared_Prefix;
695 ------------------------------
696 -- Check_Infinite_Recursion --
697 ------------------------------
699 function Check_Infinite_Recursion (Call : Node_Id) return Boolean is
700 function Enclosing_Declaration_Or_Statement (N : Node_Id) return Node_Id;
701 -- Return the nearest enclosing declaration or statement that houses
704 function Invoked_With_Different_Arguments (N : Node_Id) return Boolean;
705 -- Determine whether call N invokes the related enclosing subprogram
706 -- with actuals that differ from the subprogram's formals.
708 function Is_Conditional_Statement (N : Node_Id) return Boolean;
709 -- Determine whether arbitrary node N denotes a conditional construct
711 function Is_Control_Flow_Statement (N : Node_Id) return Boolean;
712 -- Determine whether arbitrary node N denotes a control flow statement
713 -- or a construct that may contains such a statement.
715 function Is_Immediately_Within_Body (N : Node_Id) return Boolean;
716 -- Determine whether arbitrary node N appears immediately within the
717 -- statements of an entry or subprogram body.
719 function Is_Raise_Idiom (N : Node_Id) return Boolean;
720 -- Determine whether arbitrary node N appears immediately within the
721 -- body of an entry or subprogram, and is preceded by a single raise
724 function Is_Raise_Statement (N : Node_Id) return Boolean;
725 -- Determine whether arbitrary node N denotes a raise statement
727 function Is_Sole_Statement (N : Node_Id) return Boolean;
728 -- Determine whether arbitrary node N is the sole source statement in
729 -- the body of the enclosing subprogram.
731 function Preceded_By_Control_Flow_Statement (N : Node_Id) return Boolean;
732 -- Determine whether arbitrary node N is preceded by a control flow
735 function Within_Conditional_Statement (N : Node_Id) return Boolean;
736 -- Determine whether arbitrary node N appears within a conditional
739 ----------------------------------------
740 -- Enclosing_Declaration_Or_Statement --
741 ----------------------------------------
743 function Enclosing_Declaration_Or_Statement
744 (N : Node_Id) return Node_Id
750 while Present (Par) loop
751 if Is_Declaration (Par) or else Is_Statement (Par) then
754 -- Prevent the search from going too far
756 elsif Is_Body_Or_Package_Declaration (Par) then
764 end Enclosing_Declaration_Or_Statement;
766 --------------------------------------
767 -- Invoked_With_Different_Arguments --
768 --------------------------------------
770 function Invoked_With_Different_Arguments (N : Node_Id) return Boolean is
771 Subp : constant Entity_Id := Entity (Name (N));
777 -- Determine whether the formals of the invoked subprogram are not
778 -- used as actuals in the call.
780 Actual := First_Actual (Call);
781 Formal := First_Formal (Subp);
782 while Present (Actual) and then Present (Formal) loop
784 -- The current actual does not match the current formal
786 if not (Is_Entity_Name (Actual)
787 and then Entity (Actual) = Formal)
792 Next_Actual (Actual);
793 Next_Formal (Formal);
797 end Invoked_With_Different_Arguments;
799 ------------------------------
800 -- Is_Conditional_Statement --
801 ------------------------------
803 function Is_Conditional_Statement (N : Node_Id) return Boolean is
806 Nkind_In (N, N_And_Then,
812 end Is_Conditional_Statement;
814 -------------------------------
815 -- Is_Control_Flow_Statement --
816 -------------------------------
818 function Is_Control_Flow_Statement (N : Node_Id) return Boolean is
820 -- It is assumed that all statements may affect the control flow in
821 -- some way. A raise statement may be expanded into a non-statement
824 return Is_Statement (N) or else Is_Raise_Statement (N);
825 end Is_Control_Flow_Statement;
827 --------------------------------
828 -- Is_Immediately_Within_Body --
829 --------------------------------
831 function Is_Immediately_Within_Body (N : Node_Id) return Boolean is
832 HSS : constant Node_Id := Parent (N);
836 Nkind (HSS) = N_Handled_Sequence_Of_Statements
837 and then Nkind_In (Parent (HSS), N_Entry_Body, N_Subprogram_Body)
838 and then Is_List_Member (N)
839 and then List_Containing (N) = Statements (HSS);
840 end Is_Immediately_Within_Body;
846 function Is_Raise_Idiom (N : Node_Id) return Boolean is
847 Raise_Stmt : Node_Id;
851 if Is_Immediately_Within_Body (N) then
853 -- Assume that no raise statement has been seen yet
857 -- Examine the statements preceding the input node, skipping
858 -- internally-generated constructs.
861 while Present (Stmt) loop
863 -- Multiple raise statements violate the idiom
865 if Is_Raise_Statement (Stmt) then
866 if Present (Raise_Stmt) then
872 elsif Comes_From_Source (Stmt) then
879 -- At this point the node must be preceded by a raise statement,
880 -- and the raise statement has to be the sole statement within
881 -- the enclosing entry or subprogram body.
884 Present (Raise_Stmt) and then Is_Sole_Statement (Raise_Stmt);
890 ------------------------
891 -- Is_Raise_Statement --
892 ------------------------
894 function Is_Raise_Statement (N : Node_Id) return Boolean is
896 -- A raise statement may be transfomed into a Raise_xxx_Error node
899 Nkind (N) = N_Raise_Statement
900 or else Nkind (N) in N_Raise_xxx_Error;
901 end Is_Raise_Statement;
903 -----------------------
904 -- Is_Sole_Statement --
905 -----------------------
907 function Is_Sole_Statement (N : Node_Id) return Boolean is
911 -- The input node appears within the statements of an entry or
912 -- subprogram body. Examine the statements preceding the node.
914 if Is_Immediately_Within_Body (N) then
917 while Present (Stmt) loop
919 -- The statement is preceded by another statement or a source
920 -- construct. This indicates that the node does not appear by
923 if Is_Control_Flow_Statement (Stmt)
924 or else Comes_From_Source (Stmt)
935 -- The input node is within a construct nested inside the entry or
939 end Is_Sole_Statement;
941 ----------------------------------------
942 -- Preceded_By_Control_Flow_Statement --
943 ----------------------------------------
945 function Preceded_By_Control_Flow_Statement
946 (N : Node_Id) return Boolean
951 if Is_List_Member (N) then
954 -- Examine the statements preceding the input node
956 while Present (Stmt) loop
957 if Is_Control_Flow_Statement (Stmt) then
967 -- Assume that the node is part of some control flow statement
970 end Preceded_By_Control_Flow_Statement;
972 ----------------------------------
973 -- Within_Conditional_Statement --
974 ----------------------------------
976 function Within_Conditional_Statement (N : Node_Id) return Boolean is
981 while Present (Stmt) loop
982 if Is_Conditional_Statement (Stmt) then
985 -- Prevent the search from going too far
987 elsif Is_Body_Or_Package_Declaration (Stmt) then
991 Stmt := Parent (Stmt);
995 end Within_Conditional_Statement;
999 Call_Context : constant Node_Id :=
1000 Enclosing_Declaration_Or_Statement (Call);
1002 -- Start of processing for Check_Infinite_Recursion
1005 -- The call is assumed to be safe when the enclosing subprogram is
1006 -- invoked with actuals other than its formals.
1008 -- procedure Proc (F1 : ...; F2 : ...; ...; FN : ...) is
1011 -- Proc (A1, A2, ..., AN);
1015 if Invoked_With_Different_Arguments (Call) then
1018 -- The call is assumed to be safe when the invocation of the enclosing
1019 -- subprogram depends on a conditional statement.
1021 -- procedure Proc (F1 : ...; F2 : ...; ...; FN : ...) is
1024 -- if Some_Condition then
1025 -- Proc (F1, F2, ..., FN);
1030 elsif Within_Conditional_Statement (Call) then
1033 -- The context of the call is assumed to be safe when the invocation of
1034 -- the enclosing subprogram is preceded by some control flow statement.
1036 -- procedure Proc (F1 : ...; F2 : ...; ...; FN : ...) is
1039 -- if Some_Condition then
1043 -- Proc (F1, F2, ..., FN);
1047 elsif Preceded_By_Control_Flow_Statement (Call_Context) then
1050 -- Detect an idiom where the context of the call is preceded by a single
1053 -- procedure Proc (F1 : ...; F2 : ...; ...; FN : ...) is
1056 -- Proc (F1, F2, ..., FN);
1059 elsif Is_Raise_Idiom (Call_Context) then
1063 -- At this point it is certain that infinite recursion will take place
1064 -- as long as the call is executed. Detect a case where the context of
1065 -- the call is the sole source statement within the subprogram body.
1067 -- procedure Proc (F1 : ...; F2 : ...; ...; FN : ...) is
1069 -- Proc (F1, F2, ..., FN);
1072 -- Install an explicit raise to prevent the infinite recursion.
1074 if Is_Sole_Statement (Call_Context) then
1075 Error_Msg_Warn := SPARK_Mode /= On;
1076 Error_Msg_N ("!infinite recursion<<", Call);
1077 Error_Msg_N ("\!Storage_Error [<<", Call);
1079 Insert_Action (Call,
1080 Make_Raise_Storage_Error (Sloc (Call),
1081 Reason => SE_Infinite_Recursion));
1083 -- Otherwise infinite recursion could take place, considering other flow
1084 -- control constructs such as gotos, exit statements, etc.
1087 Error_Msg_Warn := SPARK_Mode /= On;
1088 Error_Msg_N ("!possible infinite recursion<<", Call);
1089 Error_Msg_N ("\!??Storage_Error ]<<", Call);
1093 end Check_Infinite_Recursion;
1095 ---------------------------------------
1096 -- Check_No_Direct_Boolean_Operators --
1097 ---------------------------------------
1099 procedure Check_No_Direct_Boolean_Operators (N : Node_Id) is
1101 if Scope (Entity (N)) = Standard_Standard
1102 and then Root_Type (Etype (Left_Opnd (N))) = Standard_Boolean
1104 -- Restriction only applies to original source code
1106 if Comes_From_Source (N) then
1107 Check_Restriction (No_Direct_Boolean_Operators, N);
1111 -- Do style check (but skip if in instance, error is on template)
1114 if not In_Instance then
1115 Check_Boolean_Operator (N);
1118 end Check_No_Direct_Boolean_Operators;
1120 ------------------------------
1121 -- Check_Parameterless_Call --
1122 ------------------------------
1124 procedure Check_Parameterless_Call (N : Node_Id) is
1127 function Prefix_Is_Access_Subp return Boolean;
1128 -- If the prefix is of an access_to_subprogram type, the node must be
1129 -- rewritten as a call. Ditto if the prefix is overloaded and all its
1130 -- interpretations are access to subprograms.
1132 ---------------------------
1133 -- Prefix_Is_Access_Subp --
1134 ---------------------------
1136 function Prefix_Is_Access_Subp return Boolean is
1141 -- If the context is an attribute reference that can apply to
1142 -- functions, this is never a parameterless call (RM 4.1.4(6)).
1144 if Nkind (Parent (N)) = N_Attribute_Reference
1145 and then Nam_In (Attribute_Name (Parent (N)), Name_Address,
1152 if not Is_Overloaded (N) then
1154 Ekind (Etype (N)) = E_Subprogram_Type
1155 and then Base_Type (Etype (Etype (N))) /= Standard_Void_Type;
1157 Get_First_Interp (N, I, It);
1158 while Present (It.Typ) loop
1159 if Ekind (It.Typ) /= E_Subprogram_Type
1160 or else Base_Type (Etype (It.Typ)) = Standard_Void_Type
1165 Get_Next_Interp (I, It);
1170 end Prefix_Is_Access_Subp;
1172 -- Start of processing for Check_Parameterless_Call
1175 -- Defend against junk stuff if errors already detected
1177 if Total_Errors_Detected /= 0 then
1178 if Nkind (N) in N_Has_Etype and then Etype (N) = Any_Type then
1180 elsif Nkind (N) in N_Has_Chars
1181 and then not Is_Valid_Name (Chars (N))
1189 -- If the context expects a value, and the name is a procedure, this is
1190 -- most likely a missing 'Access. Don't try to resolve the parameterless
1191 -- call, error will be caught when the outer call is analyzed.
1193 if Is_Entity_Name (N)
1194 and then Ekind (Entity (N)) = E_Procedure
1195 and then not Is_Overloaded (N)
1197 Nkind_In (Parent (N), N_Parameter_Association,
1199 N_Procedure_Call_Statement)
1204 -- Rewrite as call if overloadable entity that is (or could be, in the
1205 -- overloaded case) a function call. If we know for sure that the entity
1206 -- is an enumeration literal, we do not rewrite it.
1208 -- If the entity is the name of an operator, it cannot be a call because
1209 -- operators cannot have default parameters. In this case, this must be
1210 -- a string whose contents coincide with an operator name. Set the kind
1211 -- of the node appropriately.
1213 if (Is_Entity_Name (N)
1214 and then Nkind (N) /= N_Operator_Symbol
1215 and then Is_Overloadable (Entity (N))
1216 and then (Ekind (Entity (N)) /= E_Enumeration_Literal
1217 or else Is_Overloaded (N)))
1219 -- Rewrite as call if it is an explicit dereference of an expression of
1220 -- a subprogram access type, and the subprogram type is not that of a
1221 -- procedure or entry.
1224 (Nkind (N) = N_Explicit_Dereference and then Prefix_Is_Access_Subp)
1226 -- Rewrite as call if it is a selected component which is a function,
1227 -- this is the case of a call to a protected function (which may be
1228 -- overloaded with other protected operations).
1231 (Nkind (N) = N_Selected_Component
1232 and then (Ekind (Entity (Selector_Name (N))) = E_Function
1234 (Ekind_In (Entity (Selector_Name (N)), E_Entry,
1236 and then Is_Overloaded (Selector_Name (N)))))
1238 -- If one of the above three conditions is met, rewrite as call. Apply
1239 -- the rewriting only once.
1242 if Nkind (Parent (N)) /= N_Function_Call
1243 or else N /= Name (Parent (N))
1246 -- This may be a prefixed call that was not fully analyzed, e.g.
1247 -- an actual in an instance.
1249 if Ada_Version >= Ada_2005
1250 and then Nkind (N) = N_Selected_Component
1251 and then Is_Dispatching_Operation (Entity (Selector_Name (N)))
1253 Analyze_Selected_Component (N);
1255 if Nkind (N) /= N_Selected_Component then
1260 -- The node is the name of the parameterless call. Preserve its
1261 -- descendants, which may be complex expressions.
1263 Nam := Relocate_Node (N);
1265 -- If overloaded, overload set belongs to new copy
1267 Save_Interps (N, Nam);
1269 -- Change node to parameterless function call (note that the
1270 -- Parameter_Associations associations field is left set to Empty,
1271 -- its normal default value since there are no parameters)
1273 Change_Node (N, N_Function_Call);
1275 Set_Sloc (N, Sloc (Nam));
1279 elsif Nkind (N) = N_Parameter_Association then
1280 Check_Parameterless_Call (Explicit_Actual_Parameter (N));
1282 elsif Nkind (N) = N_Operator_Symbol then
1283 Change_Operator_Symbol_To_String_Literal (N);
1284 Set_Is_Overloaded (N, False);
1285 Set_Etype (N, Any_String);
1287 end Check_Parameterless_Call;
1289 --------------------------------
1290 -- Is_Atomic_Ref_With_Address --
1291 --------------------------------
1293 function Is_Atomic_Ref_With_Address (N : Node_Id) return Boolean is
1294 Pref : constant Node_Id := Prefix (N);
1297 if not Is_Entity_Name (Pref) then
1302 Pent : constant Entity_Id := Entity (Pref);
1303 Ptyp : constant Entity_Id := Etype (Pent);
1305 return not Is_Access_Type (Ptyp)
1306 and then (Is_Atomic (Ptyp) or else Is_Atomic (Pent))
1307 and then Present (Address_Clause (Pent));
1310 end Is_Atomic_Ref_With_Address;
1312 -----------------------------
1313 -- Is_Definite_Access_Type --
1314 -----------------------------
1316 function Is_Definite_Access_Type (E : Entity_Id) return Boolean is
1317 Btyp : constant Entity_Id := Base_Type (E);
1319 return Ekind (Btyp) = E_Access_Type
1320 or else (Ekind (Btyp) = E_Access_Subprogram_Type
1321 and then Comes_From_Source (Btyp));
1322 end Is_Definite_Access_Type;
1324 ----------------------
1325 -- Is_Predefined_Op --
1326 ----------------------
1328 function Is_Predefined_Op (Nam : Entity_Id) return Boolean is
1330 -- Predefined operators are intrinsic subprograms
1332 if not Is_Intrinsic_Subprogram (Nam) then
1336 -- A call to a back-end builtin is never a predefined operator
1338 if Is_Imported (Nam) and then Present (Interface_Name (Nam)) then
1342 return not Is_Generic_Instance (Nam)
1343 and then Chars (Nam) in Any_Operator_Name
1344 and then (No (Alias (Nam)) or else Is_Predefined_Op (Alias (Nam)));
1345 end Is_Predefined_Op;
1347 -----------------------------
1348 -- Make_Call_Into_Operator --
1349 -----------------------------
1351 procedure Make_Call_Into_Operator
1356 Op_Name : constant Name_Id := Chars (Op_Id);
1357 Act1 : Node_Id := First_Actual (N);
1358 Act2 : Node_Id := Next_Actual (Act1);
1359 Error : Boolean := False;
1360 Func : constant Entity_Id := Entity (Name (N));
1361 Is_Binary : constant Boolean := Present (Act2);
1363 Opnd_Type : Entity_Id := Empty;
1364 Orig_Type : Entity_Id := Empty;
1367 type Kind_Test is access function (E : Entity_Id) return Boolean;
1369 function Operand_Type_In_Scope (S : Entity_Id) return Boolean;
1370 -- If the operand is not universal, and the operator is given by an
1371 -- expanded name, verify that the operand has an interpretation with a
1372 -- type defined in the given scope of the operator.
1374 function Type_In_P (Test : Kind_Test) return Entity_Id;
1375 -- Find a type of the given class in package Pack that contains the
1378 ---------------------------
1379 -- Operand_Type_In_Scope --
1380 ---------------------------
1382 function Operand_Type_In_Scope (S : Entity_Id) return Boolean is
1383 Nod : constant Node_Id := Right_Opnd (Op_Node);
1388 if not Is_Overloaded (Nod) then
1389 return Scope (Base_Type (Etype (Nod))) = S;
1392 Get_First_Interp (Nod, I, It);
1393 while Present (It.Typ) loop
1394 if Scope (Base_Type (It.Typ)) = S then
1398 Get_Next_Interp (I, It);
1403 end Operand_Type_In_Scope;
1409 function Type_In_P (Test : Kind_Test) return Entity_Id is
1412 function In_Decl return Boolean;
1413 -- Verify that node is not part of the type declaration for the
1414 -- candidate type, which would otherwise be invisible.
1420 function In_Decl return Boolean is
1421 Decl_Node : constant Node_Id := Parent (E);
1427 if Etype (E) = Any_Type then
1430 elsif No (Decl_Node) then
1435 and then Nkind (N2) /= N_Compilation_Unit
1437 if N2 = Decl_Node then
1448 -- Start of processing for Type_In_P
1451 -- If the context type is declared in the prefix package, this is the
1452 -- desired base type.
1454 if Scope (Base_Type (Typ)) = Pack and then Test (Typ) then
1455 return Base_Type (Typ);
1458 E := First_Entity (Pack);
1459 while Present (E) loop
1460 if Test (E) and then not In_Decl then
1471 -- Start of processing for Make_Call_Into_Operator
1474 Op_Node := New_Node (Operator_Kind (Op_Name, Is_Binary), Sloc (N));
1476 -- Ensure that the corresponding operator has the same parent as the
1477 -- original call. This guarantees that parent traversals performed by
1478 -- the ABE mechanism succeed.
1480 Set_Parent (Op_Node, Parent (N));
1485 Set_Left_Opnd (Op_Node, Relocate_Node (Act1));
1486 Set_Right_Opnd (Op_Node, Relocate_Node (Act2));
1487 Save_Interps (Act1, Left_Opnd (Op_Node));
1488 Save_Interps (Act2, Right_Opnd (Op_Node));
1489 Act1 := Left_Opnd (Op_Node);
1490 Act2 := Right_Opnd (Op_Node);
1495 Set_Right_Opnd (Op_Node, Relocate_Node (Act1));
1496 Save_Interps (Act1, Right_Opnd (Op_Node));
1497 Act1 := Right_Opnd (Op_Node);
1500 -- If the operator is denoted by an expanded name, and the prefix is
1501 -- not Standard, but the operator is a predefined one whose scope is
1502 -- Standard, then this is an implicit_operator, inserted as an
1503 -- interpretation by the procedure of the same name. This procedure
1504 -- overestimates the presence of implicit operators, because it does
1505 -- not examine the type of the operands. Verify now that the operand
1506 -- type appears in the given scope. If right operand is universal,
1507 -- check the other operand. In the case of concatenation, either
1508 -- argument can be the component type, so check the type of the result.
1509 -- If both arguments are literals, look for a type of the right kind
1510 -- defined in the given scope. This elaborate nonsense is brought to
1511 -- you courtesy of b33302a. The type itself must be frozen, so we must
1512 -- find the type of the proper class in the given scope.
1514 -- A final wrinkle is the multiplication operator for fixed point types,
1515 -- which is defined in Standard only, and not in the scope of the
1516 -- fixed point type itself.
1518 if Nkind (Name (N)) = N_Expanded_Name then
1519 Pack := Entity (Prefix (Name (N)));
1521 -- If this is a package renaming, get renamed entity, which will be
1522 -- the scope of the operands if operaton is type-correct.
1524 if Present (Renamed_Entity (Pack)) then
1525 Pack := Renamed_Entity (Pack);
1528 -- If the entity being called is defined in the given package, it is
1529 -- a renaming of a predefined operator, and known to be legal.
1531 if Scope (Entity (Name (N))) = Pack
1532 and then Pack /= Standard_Standard
1536 -- Visibility does not need to be checked in an instance: if the
1537 -- operator was not visible in the generic it has been diagnosed
1538 -- already, else there is an implicit copy of it in the instance.
1540 elsif In_Instance then
1543 elsif Nam_In (Op_Name, Name_Op_Multiply, Name_Op_Divide)
1544 and then Is_Fixed_Point_Type (Etype (Left_Opnd (Op_Node)))
1545 and then Is_Fixed_Point_Type (Etype (Right_Opnd (Op_Node)))
1547 if Pack /= Standard_Standard then
1551 -- Ada 2005 AI-420: Predefined equality on Universal_Access is
1554 elsif Ada_Version >= Ada_2005
1555 and then Nam_In (Op_Name, Name_Op_Eq, Name_Op_Ne)
1556 and then Ekind (Etype (Act1)) = E_Anonymous_Access_Type
1561 Opnd_Type := Base_Type (Etype (Right_Opnd (Op_Node)));
1563 if Op_Name = Name_Op_Concat then
1564 Opnd_Type := Base_Type (Typ);
1566 elsif (Scope (Opnd_Type) = Standard_Standard
1568 or else (Nkind (Right_Opnd (Op_Node)) = N_Attribute_Reference
1570 and then not Comes_From_Source (Opnd_Type))
1572 Opnd_Type := Base_Type (Etype (Left_Opnd (Op_Node)));
1575 if Scope (Opnd_Type) = Standard_Standard then
1577 -- Verify that the scope contains a type that corresponds to
1578 -- the given literal. Optimize the case where Pack is Standard.
1580 if Pack /= Standard_Standard then
1581 if Opnd_Type = Universal_Integer then
1582 Orig_Type := Type_In_P (Is_Integer_Type'Access);
1584 elsif Opnd_Type = Universal_Real then
1585 Orig_Type := Type_In_P (Is_Real_Type'Access);
1587 elsif Opnd_Type = Any_String then
1588 Orig_Type := Type_In_P (Is_String_Type'Access);
1590 elsif Opnd_Type = Any_Access then
1591 Orig_Type := Type_In_P (Is_Definite_Access_Type'Access);
1593 elsif Opnd_Type = Any_Composite then
1594 Orig_Type := Type_In_P (Is_Composite_Type'Access);
1596 if Present (Orig_Type) then
1597 if Has_Private_Component (Orig_Type) then
1600 Set_Etype (Act1, Orig_Type);
1603 Set_Etype (Act2, Orig_Type);
1612 Error := No (Orig_Type);
1615 elsif Ekind (Opnd_Type) = E_Allocator_Type
1616 and then No (Type_In_P (Is_Definite_Access_Type'Access))
1620 -- If the type is defined elsewhere, and the operator is not
1621 -- defined in the given scope (by a renaming declaration, e.g.)
1622 -- then this is an error as well. If an extension of System is
1623 -- present, and the type may be defined there, Pack must be
1626 elsif Scope (Opnd_Type) /= Pack
1627 and then Scope (Op_Id) /= Pack
1628 and then (No (System_Aux_Id)
1629 or else Scope (Opnd_Type) /= System_Aux_Id
1630 or else Pack /= Scope (System_Aux_Id))
1632 if not Is_Overloaded (Right_Opnd (Op_Node)) then
1635 Error := not Operand_Type_In_Scope (Pack);
1638 elsif Pack = Standard_Standard
1639 and then not Operand_Type_In_Scope (Standard_Standard)
1646 Error_Msg_Node_2 := Pack;
1648 ("& not declared in&", N, Selector_Name (Name (N)));
1649 Set_Etype (N, Any_Type);
1652 -- Detect a mismatch between the context type and the result type
1653 -- in the named package, which is otherwise not detected if the
1654 -- operands are universal. Check is only needed if source entity is
1655 -- an operator, not a function that renames an operator.
1657 elsif Nkind (Parent (N)) /= N_Type_Conversion
1658 and then Ekind (Entity (Name (N))) = E_Operator
1659 and then Is_Numeric_Type (Typ)
1660 and then not Is_Universal_Numeric_Type (Typ)
1661 and then Scope (Base_Type (Typ)) /= Pack
1662 and then not In_Instance
1664 if Is_Fixed_Point_Type (Typ)
1665 and then Nam_In (Op_Name, Name_Op_Multiply, Name_Op_Divide)
1667 -- Already checked above
1671 -- Operator may be defined in an extension of System
1673 elsif Present (System_Aux_Id)
1674 and then Present (Opnd_Type)
1675 and then Scope (Opnd_Type) = System_Aux_Id
1680 -- Could we use Wrong_Type here??? (this would require setting
1681 -- Etype (N) to the actual type found where Typ was expected).
1683 Error_Msg_NE ("expect }", N, Typ);
1688 Set_Chars (Op_Node, Op_Name);
1690 if not Is_Private_Type (Etype (N)) then
1691 Set_Etype (Op_Node, Base_Type (Etype (N)));
1693 Set_Etype (Op_Node, Etype (N));
1696 -- If this is a call to a function that renames a predefined equality,
1697 -- the renaming declaration provides a type that must be used to
1698 -- resolve the operands. This must be done now because resolution of
1699 -- the equality node will not resolve any remaining ambiguity, and it
1700 -- assumes that the first operand is not overloaded.
1702 if Nam_In (Op_Name, Name_Op_Eq, Name_Op_Ne)
1703 and then Ekind (Func) = E_Function
1704 and then Is_Overloaded (Act1)
1706 Resolve (Act1, Base_Type (Etype (First_Formal (Func))));
1707 Resolve (Act2, Base_Type (Etype (First_Formal (Func))));
1710 Set_Entity (Op_Node, Op_Id);
1711 Generate_Reference (Op_Id, N, ' ');
1713 -- Do rewrite setting Comes_From_Source on the result if the original
1714 -- call came from source. Although it is not strictly the case that the
1715 -- operator as such comes from the source, logically it corresponds
1716 -- exactly to the function call in the source, so it should be marked
1717 -- this way (e.g. to make sure that validity checks work fine).
1720 CS : constant Boolean := Comes_From_Source (N);
1722 Rewrite (N, Op_Node);
1723 Set_Comes_From_Source (N, CS);
1726 -- If this is an arithmetic operator and the result type is private,
1727 -- the operands and the result must be wrapped in conversion to
1728 -- expose the underlying numeric type and expand the proper checks,
1729 -- e.g. on division.
1731 if Is_Private_Type (Typ) then
1741 Resolve_Intrinsic_Operator (N, Typ);
1747 Resolve_Intrinsic_Unary_Operator (N, Typ);
1756 -- If in ASIS_Mode, propagate operand types to original actuals of
1757 -- function call, which would otherwise not be fully resolved. If
1758 -- the call has already been constant-folded, nothing to do. We
1759 -- relocate the operand nodes rather than copy them, to preserve
1760 -- original_node pointers, given that the operands themselves may
1761 -- have been rewritten. If the call was itself a rewriting of an
1762 -- operator node, nothing to do.
1765 and then Nkind (N) in N_Op
1766 and then Nkind (Original_Node (N)) = N_Function_Call
1770 R : constant Node_Id := Right_Opnd (N);
1772 Old_First : constant Node_Id :=
1773 First (Parameter_Associations (Original_Node (N)));
1779 Old_Sec := Next (Old_First);
1781 -- If the original call has named associations, replace the
1782 -- explicit actual parameter in the association with the proper
1783 -- resolved operand.
1785 if Nkind (Old_First) = N_Parameter_Association then
1786 if Chars (Selector_Name (Old_First)) =
1787 Chars (First_Entity (Op_Id))
1789 Rewrite (Explicit_Actual_Parameter (Old_First),
1792 Rewrite (Explicit_Actual_Parameter (Old_First),
1797 Rewrite (Old_First, Relocate_Node (L));
1800 if Nkind (Old_Sec) = N_Parameter_Association then
1801 if Chars (Selector_Name (Old_Sec)) =
1802 Chars (First_Entity (Op_Id))
1804 Rewrite (Explicit_Actual_Parameter (Old_Sec),
1807 Rewrite (Explicit_Actual_Parameter (Old_Sec),
1812 Rewrite (Old_Sec, Relocate_Node (R));
1816 if Nkind (Old_First) = N_Parameter_Association then
1817 Rewrite (Explicit_Actual_Parameter (Old_First),
1820 Rewrite (Old_First, Relocate_Node (R));
1825 Set_Parent (Original_Node (N), Parent (N));
1827 end Make_Call_Into_Operator;
1833 function Operator_Kind
1835 Is_Binary : Boolean) return Node_Kind
1840 -- Use CASE statement or array???
1843 if Op_Name = Name_Op_And then
1845 elsif Op_Name = Name_Op_Or then
1847 elsif Op_Name = Name_Op_Xor then
1849 elsif Op_Name = Name_Op_Eq then
1851 elsif Op_Name = Name_Op_Ne then
1853 elsif Op_Name = Name_Op_Lt then
1855 elsif Op_Name = Name_Op_Le then
1857 elsif Op_Name = Name_Op_Gt then
1859 elsif Op_Name = Name_Op_Ge then
1861 elsif Op_Name = Name_Op_Add then
1863 elsif Op_Name = Name_Op_Subtract then
1864 Kind := N_Op_Subtract;
1865 elsif Op_Name = Name_Op_Concat then
1866 Kind := N_Op_Concat;
1867 elsif Op_Name = Name_Op_Multiply then
1868 Kind := N_Op_Multiply;
1869 elsif Op_Name = Name_Op_Divide then
1870 Kind := N_Op_Divide;
1871 elsif Op_Name = Name_Op_Mod then
1873 elsif Op_Name = Name_Op_Rem then
1875 elsif Op_Name = Name_Op_Expon then
1878 raise Program_Error;
1884 if Op_Name = Name_Op_Add then
1886 elsif Op_Name = Name_Op_Subtract then
1888 elsif Op_Name = Name_Op_Abs then
1890 elsif Op_Name = Name_Op_Not then
1893 raise Program_Error;
1900 ----------------------------
1901 -- Preanalyze_And_Resolve --
1902 ----------------------------
1904 procedure Preanalyze_And_Resolve
1907 With_Freezing : Boolean)
1909 Save_Full_Analysis : constant Boolean := Full_Analysis;
1910 Save_Must_Not_Freeze : constant Boolean := Must_Not_Freeze (N);
1911 Save_Preanalysis_Count : constant Nat :=
1912 Inside_Preanalysis_Without_Freezing;
1914 pragma Assert (Nkind (N) in N_Subexpr);
1916 if not With_Freezing then
1917 Set_Must_Not_Freeze (N);
1918 Inside_Preanalysis_Without_Freezing :=
1919 Inside_Preanalysis_Without_Freezing + 1;
1922 Full_Analysis := False;
1923 Expander_Mode_Save_And_Set (False);
1925 -- Normally, we suppress all checks for this preanalysis. There is no
1926 -- point in processing them now, since they will be applied properly
1927 -- and in the proper location when the default expressions reanalyzed
1928 -- and reexpanded later on. We will also have more information at that
1929 -- point for possible suppression of individual checks.
1931 -- However, in SPARK mode, most expansion is suppressed, and this
1932 -- later reanalysis and reexpansion may not occur. SPARK mode does
1933 -- require the setting of checking flags for proof purposes, so we
1934 -- do the SPARK preanalysis without suppressing checks.
1936 -- This special handling for SPARK mode is required for example in the
1937 -- case of Ada 2012 constructs such as quantified expressions, which are
1938 -- expanded in two separate steps.
1940 if GNATprove_Mode then
1941 Analyze_And_Resolve (N, T);
1943 Analyze_And_Resolve (N, T, Suppress => All_Checks);
1946 Expander_Mode_Restore;
1947 Full_Analysis := Save_Full_Analysis;
1948 Set_Must_Not_Freeze (N, Save_Must_Not_Freeze);
1950 if not With_Freezing then
1951 Inside_Preanalysis_Without_Freezing :=
1952 Inside_Preanalysis_Without_Freezing - 1;
1956 (Inside_Preanalysis_Without_Freezing = Save_Preanalysis_Count);
1957 end Preanalyze_And_Resolve;
1959 ----------------------------
1960 -- Preanalyze_And_Resolve --
1961 ----------------------------
1963 procedure Preanalyze_And_Resolve (N : Node_Id; T : Entity_Id) is
1965 Preanalyze_And_Resolve (N, T, With_Freezing => False);
1966 end Preanalyze_And_Resolve;
1968 -- Version without context type
1970 procedure Preanalyze_And_Resolve (N : Node_Id) is
1971 Save_Full_Analysis : constant Boolean := Full_Analysis;
1974 Full_Analysis := False;
1975 Expander_Mode_Save_And_Set (False);
1978 Resolve (N, Etype (N), Suppress => All_Checks);
1980 Expander_Mode_Restore;
1981 Full_Analysis := Save_Full_Analysis;
1982 end Preanalyze_And_Resolve;
1984 ------------------------------------------
1985 -- Preanalyze_With_Freezing_And_Resolve --
1986 ------------------------------------------
1988 procedure Preanalyze_With_Freezing_And_Resolve
1993 Preanalyze_And_Resolve (N, T, With_Freezing => True);
1994 end Preanalyze_With_Freezing_And_Resolve;
1996 ----------------------------------
1997 -- Replace_Actual_Discriminants --
1998 ----------------------------------
2000 procedure Replace_Actual_Discriminants (N : Node_Id; Default : Node_Id) is
2001 Loc : constant Source_Ptr := Sloc (N);
2002 Tsk : Node_Id := Empty;
2004 function Process_Discr (Nod : Node_Id) return Traverse_Result;
2005 -- Comment needed???
2011 function Process_Discr (Nod : Node_Id) return Traverse_Result is
2015 if Nkind (Nod) = N_Identifier then
2016 Ent := Entity (Nod);
2019 and then Ekind (Ent) = E_Discriminant
2022 Make_Selected_Component (Loc,
2023 Prefix => New_Copy_Tree (Tsk, New_Sloc => Loc),
2024 Selector_Name => Make_Identifier (Loc, Chars (Ent))));
2026 Set_Etype (Nod, Etype (Ent));
2034 procedure Replace_Discrs is new Traverse_Proc (Process_Discr);
2036 -- Start of processing for Replace_Actual_Discriminants
2039 if Expander_Active then
2042 -- Allow the replacement of concurrent discriminants in GNATprove even
2043 -- though this is a light expansion activity. Note that generic units
2044 -- are not modified.
2046 elsif GNATprove_Mode and not Inside_A_Generic then
2053 if Nkind (Name (N)) = N_Selected_Component then
2054 Tsk := Prefix (Name (N));
2056 elsif Nkind (Name (N)) = N_Indexed_Component then
2057 Tsk := Prefix (Prefix (Name (N)));
2060 if Present (Tsk) then
2061 Replace_Discrs (Default);
2063 end Replace_Actual_Discriminants;
2069 procedure Resolve (N : Node_Id; Typ : Entity_Id) is
2070 Ambiguous : Boolean := False;
2071 Ctx_Type : Entity_Id := Typ;
2072 Expr_Type : Entity_Id := Empty; -- prevent junk warning
2073 Err_Type : Entity_Id := Empty;
2074 Found : Boolean := False;
2077 I1 : Interp_Index := 0; -- prevent junk warning
2080 Seen : Entity_Id := Empty; -- prevent junk warning
2082 function Comes_From_Predefined_Lib_Unit (Nod : Node_Id) return Boolean;
2083 -- Determine whether a node comes from a predefined library unit or
2086 procedure Patch_Up_Value (N : Node_Id; Typ : Entity_Id);
2087 -- Try and fix up a literal so that it matches its expected type. New
2088 -- literals are manufactured if necessary to avoid cascaded errors.
2090 procedure Report_Ambiguous_Argument;
2091 -- Additional diagnostics when an ambiguous call has an ambiguous
2092 -- argument (typically a controlling actual).
2094 procedure Resolution_Failed;
2095 -- Called when attempt at resolving current expression fails
2097 ------------------------------------
2098 -- Comes_From_Predefined_Lib_Unit --
2099 -------------------------------------
2101 function Comes_From_Predefined_Lib_Unit (Nod : Node_Id) return Boolean is
2104 Sloc (Nod) = Standard_Location or else In_Predefined_Unit (Nod);
2105 end Comes_From_Predefined_Lib_Unit;
2107 --------------------
2108 -- Patch_Up_Value --
2109 --------------------
2111 procedure Patch_Up_Value (N : Node_Id; Typ : Entity_Id) is
2113 if Nkind (N) = N_Integer_Literal and then Is_Real_Type (Typ) then
2115 Make_Real_Literal (Sloc (N),
2116 Realval => UR_From_Uint (Intval (N))));
2117 Set_Etype (N, Universal_Real);
2118 Set_Is_Static_Expression (N);
2120 elsif Nkind (N) = N_Real_Literal and then Is_Integer_Type (Typ) then
2122 Make_Integer_Literal (Sloc (N),
2123 Intval => UR_To_Uint (Realval (N))));
2124 Set_Etype (N, Universal_Integer);
2125 Set_Is_Static_Expression (N);
2127 elsif Nkind (N) = N_String_Literal
2128 and then Is_Character_Type (Typ)
2130 Set_Character_Literal_Name (Char_Code (Character'Pos ('A')));
2132 Make_Character_Literal (Sloc (N),
2134 Char_Literal_Value =>
2135 UI_From_Int (Character'Pos ('A'))));
2136 Set_Etype (N, Any_Character);
2137 Set_Is_Static_Expression (N);
2139 elsif Nkind (N) /= N_String_Literal and then Is_String_Type (Typ) then
2141 Make_String_Literal (Sloc (N),
2142 Strval => End_String));
2144 elsif Nkind (N) = N_Range then
2145 Patch_Up_Value (Low_Bound (N), Typ);
2146 Patch_Up_Value (High_Bound (N), Typ);
2150 -------------------------------
2151 -- Report_Ambiguous_Argument --
2152 -------------------------------
2154 procedure Report_Ambiguous_Argument is
2155 Arg : constant Node_Id := First (Parameter_Associations (N));
2160 if Nkind (Arg) = N_Function_Call
2161 and then Is_Entity_Name (Name (Arg))
2162 and then Is_Overloaded (Name (Arg))
2164 Error_Msg_NE ("ambiguous call to&", Arg, Name (Arg));
2166 -- Could use comments on what is going on here???
2168 Get_First_Interp (Name (Arg), I, It);
2169 while Present (It.Nam) loop
2170 Error_Msg_Sloc := Sloc (It.Nam);
2172 if Nkind (Parent (It.Nam)) = N_Full_Type_Declaration then
2173 Error_Msg_N ("interpretation (inherited) #!", Arg);
2175 Error_Msg_N ("interpretation #!", Arg);
2178 Get_Next_Interp (I, It);
2181 end Report_Ambiguous_Argument;
2183 -----------------------
2184 -- Resolution_Failed --
2185 -----------------------
2187 procedure Resolution_Failed is
2189 Patch_Up_Value (N, Typ);
2191 -- Set the type to the desired one to minimize cascaded errors. Note
2192 -- that this is an approximation and does not work in all cases.
2196 Debug_A_Exit ("resolving ", N, " (done, resolution failed)");
2197 Set_Is_Overloaded (N, False);
2199 -- The caller will return without calling the expander, so we need
2200 -- to set the analyzed flag. Note that it is fine to set Analyzed
2201 -- to True even if we are in the middle of a shallow analysis,
2202 -- (see the spec of sem for more details) since this is an error
2203 -- situation anyway, and there is no point in repeating the
2204 -- analysis later (indeed it won't work to repeat it later, since
2205 -- we haven't got a clear resolution of which entity is being
2208 Set_Analyzed (N, True);
2210 end Resolution_Failed;
2212 -- Start of processing for Resolve
2219 -- Access attribute on remote subprogram cannot be used for a non-remote
2220 -- access-to-subprogram type.
2222 if Nkind (N) = N_Attribute_Reference
2223 and then Nam_In (Attribute_Name (N), Name_Access,
2224 Name_Unrestricted_Access,
2225 Name_Unchecked_Access)
2226 and then Comes_From_Source (N)
2227 and then Is_Entity_Name (Prefix (N))
2228 and then Is_Subprogram (Entity (Prefix (N)))
2229 and then Is_Remote_Call_Interface (Entity (Prefix (N)))
2230 and then not Is_Remote_Access_To_Subprogram_Type (Typ)
2233 ("prefix must statically denote a non-remote subprogram", N);
2236 From_Lib := Comes_From_Predefined_Lib_Unit (N);
2238 -- If the context is a Remote_Access_To_Subprogram, access attributes
2239 -- must be resolved with the corresponding fat pointer. There is no need
2240 -- to check for the attribute name since the return type of an
2241 -- attribute is never a remote type.
2243 if Nkind (N) = N_Attribute_Reference
2244 and then Comes_From_Source (N)
2245 and then (Is_Remote_Call_Interface (Typ) or else Is_Remote_Types (Typ))
2248 Attr : constant Attribute_Id :=
2249 Get_Attribute_Id (Attribute_Name (N));
2250 Pref : constant Node_Id := Prefix (N);
2253 Is_Remote : Boolean := True;
2256 -- Check that Typ is a remote access-to-subprogram type
2258 if Is_Remote_Access_To_Subprogram_Type (Typ) then
2260 -- Prefix (N) must statically denote a remote subprogram
2261 -- declared in a package specification.
2263 if Attr = Attribute_Access or else
2264 Attr = Attribute_Unchecked_Access or else
2265 Attr = Attribute_Unrestricted_Access
2267 Decl := Unit_Declaration_Node (Entity (Pref));
2269 if Nkind (Decl) = N_Subprogram_Body then
2270 Spec := Corresponding_Spec (Decl);
2272 if Present (Spec) then
2273 Decl := Unit_Declaration_Node (Spec);
2277 Spec := Parent (Decl);
2279 if not Is_Entity_Name (Prefix (N))
2280 or else Nkind (Spec) /= N_Package_Specification
2282 not Is_Remote_Call_Interface (Defining_Entity (Spec))
2286 ("prefix must statically denote a remote subprogram ",
2290 -- If we are generating code in distributed mode, perform
2291 -- semantic checks against corresponding remote entities.
2294 and then Get_PCS_Name /= Name_No_DSA
2296 Check_Subtype_Conformant
2297 (New_Id => Entity (Prefix (N)),
2298 Old_Id => Designated_Type
2299 (Corresponding_Remote_Type (Typ)),
2303 Process_Remote_AST_Attribute (N, Typ);
2311 Debug_A_Entry ("resolving ", N);
2313 if Debug_Flag_V then
2314 Write_Overloads (N);
2317 if Comes_From_Source (N) then
2318 if Is_Fixed_Point_Type (Typ) then
2319 Check_Restriction (No_Fixed_Point, N);
2321 elsif Is_Floating_Point_Type (Typ)
2322 and then Typ /= Universal_Real
2323 and then Typ /= Any_Real
2325 Check_Restriction (No_Floating_Point, N);
2329 -- Return if already analyzed
2331 if Analyzed (N) then
2332 Debug_A_Exit ("resolving ", N, " (done, already analyzed)");
2333 Analyze_Dimension (N);
2336 -- Any case of Any_Type as the Etype value means that we had a
2339 elsif Etype (N) = Any_Type then
2340 Debug_A_Exit ("resolving ", N, " (done, Etype = Any_Type)");
2344 Check_Parameterless_Call (N);
2346 -- The resolution of an Expression_With_Actions is determined by
2349 if Nkind (N) = N_Expression_With_Actions then
2350 Resolve (Expression (N), Typ);
2353 Expr_Type := Etype (Expression (N));
2355 -- If not overloaded, then we know the type, and all that needs doing
2356 -- is to check that this type is compatible with the context.
2358 elsif not Is_Overloaded (N) then
2359 Found := Covers (Typ, Etype (N));
2360 Expr_Type := Etype (N);
2362 -- In the overloaded case, we must select the interpretation that
2363 -- is compatible with the context (i.e. the type passed to Resolve)
2366 -- Loop through possible interpretations
2368 Get_First_Interp (N, I, It);
2369 Interp_Loop : while Present (It.Typ) loop
2370 if Debug_Flag_V then
2371 Write_Str ("Interp: ");
2375 -- We are only interested in interpretations that are compatible
2376 -- with the expected type, any other interpretations are ignored.
2378 if not Covers (Typ, It.Typ) then
2379 if Debug_Flag_V then
2380 Write_Str (" interpretation incompatible with context");
2385 -- Skip the current interpretation if it is disabled by an
2386 -- abstract operator. This action is performed only when the
2387 -- type against which we are resolving is the same as the
2388 -- type of the interpretation.
2390 if Ada_Version >= Ada_2005
2391 and then It.Typ = Typ
2392 and then Typ /= Universal_Integer
2393 and then Typ /= Universal_Real
2394 and then Present (It.Abstract_Op)
2396 if Debug_Flag_V then
2397 Write_Line ("Skip.");
2403 -- First matching interpretation
2409 Expr_Type := It.Typ;
2411 -- Matching interpretation that is not the first, maybe an
2412 -- error, but there are some cases where preference rules are
2413 -- used to choose between the two possibilities. These and
2414 -- some more obscure cases are handled in Disambiguate.
2417 -- If the current statement is part of a predefined library
2418 -- unit, then all interpretations which come from user level
2419 -- packages should not be considered. Check previous and
2423 if not Comes_From_Predefined_Lib_Unit (It.Nam) then
2426 elsif not Comes_From_Predefined_Lib_Unit (Seen) then
2428 -- Previous interpretation must be discarded
2432 Expr_Type := It.Typ;
2433 Set_Entity (N, Seen);
2438 -- Otherwise apply further disambiguation steps
2440 Error_Msg_Sloc := Sloc (Seen);
2441 It1 := Disambiguate (N, I1, I, Typ);
2443 -- Disambiguation has succeeded. Skip the remaining
2446 if It1 /= No_Interp then
2448 Expr_Type := It1.Typ;
2450 while Present (It.Typ) loop
2451 Get_Next_Interp (I, It);
2455 -- Before we issue an ambiguity complaint, check for the
2456 -- case of a subprogram call where at least one of the
2457 -- arguments is Any_Type, and if so suppress the message,
2458 -- since it is a cascaded error. This can also happen for
2459 -- a generalized indexing operation.
2461 if Nkind (N) in N_Subprogram_Call
2462 or else (Nkind (N) = N_Indexed_Component
2463 and then Present (Generalized_Indexing (N)))
2470 if Nkind (N) = N_Indexed_Component then
2471 Rewrite (N, Generalized_Indexing (N));
2474 A := First_Actual (N);
2475 while Present (A) loop
2478 if Nkind (E) = N_Parameter_Association then
2479 E := Explicit_Actual_Parameter (E);
2482 if Etype (E) = Any_Type then
2483 if Debug_Flag_V then
2484 Write_Str ("Any_Type in call");
2495 elsif Nkind (N) in N_Binary_Op
2496 and then (Etype (Left_Opnd (N)) = Any_Type
2497 or else Etype (Right_Opnd (N)) = Any_Type)
2501 elsif Nkind (N) in N_Unary_Op
2502 and then Etype (Right_Opnd (N)) = Any_Type
2507 -- Not that special case, so issue message using the flag
2508 -- Ambiguous to control printing of the header message
2509 -- only at the start of an ambiguous set.
2511 if not Ambiguous then
2512 if Nkind (N) = N_Function_Call
2513 and then Nkind (Name (N)) = N_Explicit_Dereference
2516 ("ambiguous expression (cannot resolve indirect "
2519 Error_Msg_NE -- CODEFIX
2520 ("ambiguous expression (cannot resolve&)!",
2526 if Nkind (Parent (Seen)) = N_Full_Type_Declaration then
2528 ("\\possible interpretation (inherited)#!", N);
2530 Error_Msg_N -- CODEFIX
2531 ("\\possible interpretation#!", N);
2534 if Nkind (N) in N_Subprogram_Call
2535 and then Present (Parameter_Associations (N))
2537 Report_Ambiguous_Argument;
2541 Error_Msg_Sloc := Sloc (It.Nam);
2543 -- By default, the error message refers to the candidate
2544 -- interpretation. But if it is a predefined operator, it
2545 -- is implicitly declared at the declaration of the type
2546 -- of the operand. Recover the sloc of that declaration
2547 -- for the error message.
2549 if Nkind (N) in N_Op
2550 and then Scope (It.Nam) = Standard_Standard
2551 and then not Is_Overloaded (Right_Opnd (N))
2552 and then Scope (Base_Type (Etype (Right_Opnd (N)))) /=
2555 Err_Type := First_Subtype (Etype (Right_Opnd (N)));
2557 if Comes_From_Source (Err_Type)
2558 and then Present (Parent (Err_Type))
2560 Error_Msg_Sloc := Sloc (Parent (Err_Type));
2563 elsif Nkind (N) in N_Binary_Op
2564 and then Scope (It.Nam) = Standard_Standard
2565 and then not Is_Overloaded (Left_Opnd (N))
2566 and then Scope (Base_Type (Etype (Left_Opnd (N)))) /=
2569 Err_Type := First_Subtype (Etype (Left_Opnd (N)));
2571 if Comes_From_Source (Err_Type)
2572 and then Present (Parent (Err_Type))
2574 Error_Msg_Sloc := Sloc (Parent (Err_Type));
2577 -- If this is an indirect call, use the subprogram_type
2578 -- in the message, to have a meaningful location. Also
2579 -- indicate if this is an inherited operation, created
2580 -- by a type declaration.
2582 elsif Nkind (N) = N_Function_Call
2583 and then Nkind (Name (N)) = N_Explicit_Dereference
2584 and then Is_Type (It.Nam)
2588 Sloc (Associated_Node_For_Itype (Err_Type));
2593 if Nkind (N) in N_Op
2594 and then Scope (It.Nam) = Standard_Standard
2595 and then Present (Err_Type)
2597 -- Special-case the message for universal_fixed
2598 -- operators, which are not declared with the type
2599 -- of the operand, but appear forever in Standard.
2601 if It.Typ = Universal_Fixed
2602 and then Scope (It.Nam) = Standard_Standard
2605 ("\\possible interpretation as universal_fixed "
2606 & "operation (RM 4.5.5 (19))", N);
2609 ("\\possible interpretation (predefined)#!", N);
2613 Nkind (Parent (It.Nam)) = N_Full_Type_Declaration
2616 ("\\possible interpretation (inherited)#!", N);
2618 Error_Msg_N -- CODEFIX
2619 ("\\possible interpretation#!", N);
2625 -- We have a matching interpretation, Expr_Type is the type
2626 -- from this interpretation, and Seen is the entity.
2628 -- For an operator, just set the entity name. The type will be
2629 -- set by the specific operator resolution routine.
2631 if Nkind (N) in N_Op then
2632 Set_Entity (N, Seen);
2633 Generate_Reference (Seen, N);
2635 elsif Nkind_In (N, N_Case_Expression,
2636 N_Character_Literal,
2640 Set_Etype (N, Expr_Type);
2642 -- AI05-0139-2: Expression is overloaded because type has
2643 -- implicit dereference. If type matches context, no implicit
2644 -- dereference is involved. If the expression is an entity,
2645 -- generate a reference to it, as this is not done for an
2646 -- overloaded construct during analysis.
2648 elsif Has_Implicit_Dereference (Expr_Type) then
2649 Set_Etype (N, Expr_Type);
2650 Set_Is_Overloaded (N, False);
2652 if Is_Entity_Name (N) then
2653 Generate_Reference (Entity (N), N);
2658 elsif Is_Overloaded (N)
2659 and then Present (It.Nam)
2660 and then Ekind (It.Nam) = E_Discriminant
2661 and then Has_Implicit_Dereference (It.Nam)
2663 -- If the node is a general indexing, the dereference is
2664 -- is inserted when resolving the rewritten form, else
2667 if Nkind (N) /= N_Indexed_Component
2668 or else No (Generalized_Indexing (N))
2670 Build_Explicit_Dereference (N, It.Nam);
2673 -- For an explicit dereference, attribute reference, range,
2674 -- short-circuit form (which is not an operator node), or call
2675 -- with a name that is an explicit dereference, there is
2676 -- nothing to be done at this point.
2678 elsif Nkind_In (N, N_Attribute_Reference,
2680 N_Explicit_Dereference,
2682 N_Indexed_Component,
2685 N_Selected_Component,
2687 or else Nkind (Name (N)) = N_Explicit_Dereference
2691 -- For procedure or function calls, set the type of the name,
2692 -- and also the entity pointer for the prefix.
2694 elsif Nkind (N) in N_Subprogram_Call
2695 and then Is_Entity_Name (Name (N))
2697 Set_Etype (Name (N), Expr_Type);
2698 Set_Entity (Name (N), Seen);
2699 Generate_Reference (Seen, Name (N));
2701 elsif Nkind (N) = N_Function_Call
2702 and then Nkind (Name (N)) = N_Selected_Component
2704 Set_Etype (Name (N), Expr_Type);
2705 Set_Entity (Selector_Name (Name (N)), Seen);
2706 Generate_Reference (Seen, Selector_Name (Name (N)));
2708 -- For all other cases, just set the type of the Name
2711 Set_Etype (Name (N), Expr_Type);
2718 -- Move to next interpretation
2720 exit Interp_Loop when No (It.Typ);
2722 Get_Next_Interp (I, It);
2723 end loop Interp_Loop;
2726 -- At this stage Found indicates whether or not an acceptable
2727 -- interpretation exists. If not, then we have an error, except that if
2728 -- the context is Any_Type as a result of some other error, then we
2729 -- suppress the error report.
2732 if Typ /= Any_Type then
2734 -- If type we are looking for is Void, then this is the procedure
2735 -- call case, and the error is simply that what we gave is not a
2736 -- procedure name (we think of procedure calls as expressions with
2737 -- types internally, but the user doesn't think of them this way).
2739 if Typ = Standard_Void_Type then
2741 -- Special case message if function used as a procedure
2743 if Nkind (N) = N_Procedure_Call_Statement
2744 and then Is_Entity_Name (Name (N))
2745 and then Ekind (Entity (Name (N))) = E_Function
2748 ("cannot use call to function & as a statement",
2749 Name (N), Entity (Name (N)));
2751 ("\return value of a function call cannot be ignored",
2754 -- Otherwise give general message (not clear what cases this
2755 -- covers, but no harm in providing for them).
2758 Error_Msg_N ("expect procedure name in procedure call", N);
2763 -- Otherwise we do have a subexpression with the wrong type
2765 -- Check for the case of an allocator which uses an access type
2766 -- instead of the designated type. This is a common error and we
2767 -- specialize the message, posting an error on the operand of the
2768 -- allocator, complaining that we expected the designated type of
2771 elsif Nkind (N) = N_Allocator
2772 and then Is_Access_Type (Typ)
2773 and then Is_Access_Type (Etype (N))
2774 and then Designated_Type (Etype (N)) = Typ
2776 Wrong_Type (Expression (N), Designated_Type (Typ));
2779 -- Check for view mismatch on Null in instances, for which the
2780 -- view-swapping mechanism has no identifier.
2782 elsif (In_Instance or else In_Inlined_Body)
2783 and then (Nkind (N) = N_Null)
2784 and then Is_Private_Type (Typ)
2785 and then Is_Access_Type (Full_View (Typ))
2787 Resolve (N, Full_View (Typ));
2791 -- Check for an aggregate. Sometimes we can get bogus aggregates
2792 -- from misuse of parentheses, and we are about to complain about
2793 -- the aggregate without even looking inside it.
2795 -- Instead, if we have an aggregate of type Any_Composite, then
2796 -- analyze and resolve the component fields, and then only issue
2797 -- another message if we get no errors doing this (otherwise
2798 -- assume that the errors in the aggregate caused the problem).
2800 elsif Nkind (N) = N_Aggregate
2801 and then Etype (N) = Any_Composite
2803 -- Disable expansion in any case. If there is a type mismatch
2804 -- it may be fatal to try to expand the aggregate. The flag
2805 -- would otherwise be set to false when the error is posted.
2807 Expander_Active := False;
2810 procedure Check_Aggr (Aggr : Node_Id);
2811 -- Check one aggregate, and set Found to True if we have a
2812 -- definite error in any of its elements
2814 procedure Check_Elmt (Aelmt : Node_Id);
2815 -- Check one element of aggregate and set Found to True if
2816 -- we definitely have an error in the element.
2822 procedure Check_Aggr (Aggr : Node_Id) is
2826 if Present (Expressions (Aggr)) then
2827 Elmt := First (Expressions (Aggr));
2828 while Present (Elmt) loop
2834 if Present (Component_Associations (Aggr)) then
2835 Elmt := First (Component_Associations (Aggr));
2836 while Present (Elmt) loop
2838 -- If this is a default-initialized component, then
2839 -- there is nothing to check. The box will be
2840 -- replaced by the appropriate call during late
2843 if Nkind (Elmt) /= N_Iterated_Component_Association
2844 and then not Box_Present (Elmt)
2846 Check_Elmt (Expression (Elmt));
2858 procedure Check_Elmt (Aelmt : Node_Id) is
2860 -- If we have a nested aggregate, go inside it (to
2861 -- attempt a naked analyze-resolve of the aggregate can
2862 -- cause undesirable cascaded errors). Do not resolve
2863 -- expression if it needs a type from context, as for
2864 -- integer * fixed expression.
2866 if Nkind (Aelmt) = N_Aggregate then
2872 if not Is_Overloaded (Aelmt)
2873 and then Etype (Aelmt) /= Any_Fixed
2878 if Etype (Aelmt) = Any_Type then
2889 -- Looks like we have a type error, but check for special case
2890 -- of Address wanted, integer found, with the configuration pragma
2891 -- Allow_Integer_Address active. If we have this case, introduce
2892 -- an unchecked conversion to allow the integer expression to be
2893 -- treated as an Address. The reverse case of integer wanted,
2894 -- Address found, is treated in an analogous manner.
2896 if Address_Integer_Convert_OK (Typ, Etype (N)) then
2897 Rewrite (N, Unchecked_Convert_To (Typ, Relocate_Node (N)));
2898 Analyze_And_Resolve (N, Typ);
2901 -- Under relaxed RM semantics silently replace occurrences of null
2902 -- by System.Address_Null.
2904 elsif Null_To_Null_Address_Convert_OK (N, Typ) then
2905 Replace_Null_By_Null_Address (N);
2906 Analyze_And_Resolve (N, Typ);
2910 -- That special Allow_Integer_Address check did not apply, so we
2911 -- have a real type error. If an error message was issued already,
2912 -- Found got reset to True, so if it's still False, issue standard
2913 -- Wrong_Type message.
2916 if Is_Overloaded (N) and then Nkind (N) = N_Function_Call then
2918 Subp_Name : Node_Id;
2921 if Is_Entity_Name (Name (N)) then
2922 Subp_Name := Name (N);
2924 elsif Nkind (Name (N)) = N_Selected_Component then
2926 -- Protected operation: retrieve operation name
2928 Subp_Name := Selector_Name (Name (N));
2931 raise Program_Error;
2934 Error_Msg_Node_2 := Typ;
2936 ("no visible interpretation of& matches expected type&",
2940 if All_Errors_Mode then
2942 Index : Interp_Index;
2946 Error_Msg_N ("\\possible interpretations:", N);
2948 Get_First_Interp (Name (N), Index, It);
2949 while Present (It.Nam) loop
2950 Error_Msg_Sloc := Sloc (It.Nam);
2951 Error_Msg_Node_2 := It.Nam;
2953 ("\\ type& for & declared#", N, It.Typ);
2954 Get_Next_Interp (Index, It);
2959 Error_Msg_N ("\use -gnatf for details", N);
2963 Wrong_Type (N, Typ);
2971 -- Test if we have more than one interpretation for the context
2973 elsif Ambiguous then
2977 -- Only one intepretation
2980 -- In Ada 2005, if we have something like "X : T := 2 + 2;", where
2981 -- the "+" on T is abstract, and the operands are of universal type,
2982 -- the above code will have (incorrectly) resolved the "+" to the
2983 -- universal one in Standard. Therefore check for this case and give
2984 -- an error. We can't do this earlier, because it would cause legal
2985 -- cases to get errors (when some other type has an abstract "+").
2987 if Ada_Version >= Ada_2005
2988 and then Nkind (N) in N_Op
2989 and then Is_Overloaded (N)
2990 and then Is_Universal_Numeric_Type (Etype (Entity (N)))
2992 Get_First_Interp (N, I, It);
2993 while Present (It.Typ) loop
2994 if Present (It.Abstract_Op) and then
2995 Etype (It.Abstract_Op) = Typ
2998 ("cannot call abstract subprogram &!", N, It.Abstract_Op);
3002 Get_Next_Interp (I, It);
3006 -- Here we have an acceptable interpretation for the context
3008 -- Propagate type information and normalize tree for various
3009 -- predefined operations. If the context only imposes a class of
3010 -- types, rather than a specific type, propagate the actual type
3013 if Typ = Any_Integer or else
3014 Typ = Any_Boolean or else
3015 Typ = Any_Modular or else
3016 Typ = Any_Real or else
3019 Ctx_Type := Expr_Type;
3021 -- Any_Fixed is legal in a real context only if a specific fixed-
3022 -- point type is imposed. If Norman Cohen can be confused by this,
3023 -- it deserves a separate message.
3026 and then Expr_Type = Any_Fixed
3028 Error_Msg_N ("illegal context for mixed mode operation", N);
3029 Set_Etype (N, Universal_Real);
3030 Ctx_Type := Universal_Real;
3034 -- A user-defined operator is transformed into a function call at
3035 -- this point, so that further processing knows that operators are
3036 -- really operators (i.e. are predefined operators). User-defined
3037 -- operators that are intrinsic are just renamings of the predefined
3038 -- ones, and need not be turned into calls either, but if they rename
3039 -- a different operator, we must transform the node accordingly.
3040 -- Instantiations of Unchecked_Conversion are intrinsic but are
3041 -- treated as functions, even if given an operator designator.
3043 if Nkind (N) in N_Op
3044 and then Present (Entity (N))
3045 and then Ekind (Entity (N)) /= E_Operator
3047 if not Is_Predefined_Op (Entity (N)) then
3048 Rewrite_Operator_As_Call (N, Entity (N));
3050 elsif Present (Alias (Entity (N)))
3052 Nkind (Parent (Parent (Entity (N)))) =
3053 N_Subprogram_Renaming_Declaration
3055 Rewrite_Renamed_Operator (N, Alias (Entity (N)), Typ);
3057 -- If the node is rewritten, it will be fully resolved in
3058 -- Rewrite_Renamed_Operator.
3060 if Analyzed (N) then
3066 case N_Subexpr'(Nkind (N)) is
3068 Resolve_Aggregate (N, Ctx_Type);
3071 Resolve_Allocator (N, Ctx_Type);
3073 when N_Short_Circuit =>
3074 Resolve_Short_Circuit (N, Ctx_Type);
3076 when N_Attribute_Reference =>
3077 Resolve_Attribute (N, Ctx_Type);
3079 when N_Case_Expression =>
3080 Resolve_Case_Expression (N, Ctx_Type);
3082 when N_Character_Literal =>
3083 Resolve_Character_Literal (N, Ctx_Type);
3085 when N_Delta_Aggregate =>
3086 Resolve_Delta_Aggregate (N, Ctx_Type);
3088 when N_Expanded_Name =>
3089 Resolve_Entity_Name (N, Ctx_Type);
3091 when N_Explicit_Dereference =>
3092 Resolve_Explicit_Dereference (N, Ctx_Type);
3094 when N_Expression_With_Actions =>
3095 Resolve_Expression_With_Actions (N, Ctx_Type);
3097 when N_Extension_Aggregate =>
3098 Resolve_Extension_Aggregate (N, Ctx_Type);
3100 when N_Function_Call =>
3101 Resolve_Call (N, Ctx_Type);
3103 when N_Identifier =>
3104 Resolve_Entity_Name (N, Ctx_Type);
3106 when N_If_Expression =>
3107 Resolve_If_Expression (N, Ctx_Type);
3109 when N_Indexed_Component =>
3110 Resolve_Indexed_Component (N, Ctx_Type);
3112 when N_Integer_Literal =>
3113 Resolve_Integer_Literal (N, Ctx_Type);
3115 when N_Membership_Test =>
3116 Resolve_Membership_Op (N, Ctx_Type);
3119 Resolve_Null (N, Ctx_Type);
3125 Resolve_Logical_Op (N, Ctx_Type);
3130 Resolve_Equality_Op (N, Ctx_Type);
3137 Resolve_Comparison_Op (N, Ctx_Type);
3140 Resolve_Op_Not (N, Ctx_Type);
3149 Resolve_Arithmetic_Op (N, Ctx_Type);
3152 Resolve_Op_Concat (N, Ctx_Type);
3155 Resolve_Op_Expon (N, Ctx_Type);
3161 Resolve_Unary_Op (N, Ctx_Type);
3164 Resolve_Shift (N, Ctx_Type);
3166 when N_Procedure_Call_Statement =>
3167 Resolve_Call (N, Ctx_Type);
3169 when N_Operator_Symbol =>
3170 Resolve_Operator_Symbol (N, Ctx_Type);
3172 when N_Qualified_Expression =>
3173 Resolve_Qualified_Expression (N, Ctx_Type);
3175 -- Why is the following null, needs a comment ???
3177 when N_Quantified_Expression =>
3180 when N_Raise_Expression =>
3181 Resolve_Raise_Expression (N, Ctx_Type);
3183 when N_Raise_xxx_Error =>
3184 Set_Etype (N, Ctx_Type);
3187 Resolve_Range (N, Ctx_Type);
3189 when N_Real_Literal =>
3190 Resolve_Real_Literal (N, Ctx_Type);
3193 Resolve_Reference (N, Ctx_Type);
3195 when N_Selected_Component =>
3196 Resolve_Selected_Component (N, Ctx_Type);
3199 Resolve_Slice (N, Ctx_Type);
3201 when N_String_Literal =>
3202 Resolve_String_Literal (N, Ctx_Type);
3204 when N_Target_Name =>
3205 Resolve_Target_Name (N, Ctx_Type);
3207 when N_Type_Conversion =>
3208 Resolve_Type_Conversion (N, Ctx_Type);
3210 when N_Unchecked_Expression =>
3211 Resolve_Unchecked_Expression (N, Ctx_Type);
3213 when N_Unchecked_Type_Conversion =>
3214 Resolve_Unchecked_Type_Conversion (N, Ctx_Type);
3217 -- Mark relevant use-type and use-package clauses as effective using
3218 -- the original node because constant folding may have occured and
3219 -- removed references that need to be examined.
3221 if Nkind (Original_Node (N)) in N_Op then
3222 Mark_Use_Clauses (Original_Node (N));
3225 -- Ada 2012 (AI05-0149): Apply an (implicit) conversion to an
3226 -- expression of an anonymous access type that occurs in the context
3227 -- of a named general access type, except when the expression is that
3228 -- of a membership test. This ensures proper legality checking in
3229 -- terms of allowed conversions (expressions that would be illegal to
3230 -- convert implicitly are allowed in membership tests).
3232 if Ada_Version >= Ada_2012
3233 and then Ekind (Ctx_Type) = E_General_Access_Type
3234 and then Ekind (Etype (N)) = E_Anonymous_Access_Type
3235 and then Nkind (Parent (N)) not in N_Membership_Test
3237 Rewrite (N, Convert_To (Ctx_Type, Relocate_Node (N)));
3238 Analyze_And_Resolve (N, Ctx_Type);
3241 -- If the subexpression was replaced by a non-subexpression, then
3242 -- all we do is to expand it. The only legitimate case we know of
3243 -- is converting procedure call statement to entry call statements,
3244 -- but there may be others, so we are making this test general.
3246 if Nkind (N) not in N_Subexpr then
3247 Debug_A_Exit ("resolving ", N, " (done)");
3252 -- The expression is definitely NOT overloaded at this point, so
3253 -- we reset the Is_Overloaded flag to avoid any confusion when
3254 -- reanalyzing the node.
3256 Set_Is_Overloaded (N, False);
3258 -- Freeze expression type, entity if it is a name, and designated
3259 -- type if it is an allocator (RM 13.14(10,11,13)).
3261 -- Now that the resolution of the type of the node is complete, and
3262 -- we did not detect an error, we can expand this node. We skip the
3263 -- expand call if we are in a default expression, see section
3264 -- "Handling of Default Expressions" in Sem spec.
3266 Debug_A_Exit ("resolving ", N, " (done)");
3268 -- We unconditionally freeze the expression, even if we are in
3269 -- default expression mode (the Freeze_Expression routine tests this
3270 -- flag and only freezes static types if it is set).
3272 -- Ada 2012 (AI05-177): The declaration of an expression function
3273 -- does not cause freezing, but we never reach here in that case.
3274 -- Here we are resolving the corresponding expanded body, so we do
3275 -- need to perform normal freezing.
3277 -- As elsewhere we do not emit freeze node within a generic. We make
3278 -- an exception for entities that are expressions, only to detect
3279 -- misuses of deferred constants and preserve the output of various
3282 if not Inside_A_Generic or else Is_Entity_Name (N) then
3283 Freeze_Expression (N);
3286 -- Now we can do the expansion
3296 -- Version with check(s) suppressed
3298 procedure Resolve (N : Node_Id; Typ : Entity_Id; Suppress : Check_Id) is
3300 if Suppress = All_Checks then
3302 Sva : constant Suppress_Array := Scope_Suppress.Suppress;
3304 Scope_Suppress.Suppress := (others => True);
3306 Scope_Suppress.Suppress := Sva;
3311 Svg : constant Boolean := Scope_Suppress.Suppress (Suppress);
3313 Scope_Suppress.Suppress (Suppress) := True;
3315 Scope_Suppress.Suppress (Suppress) := Svg;
3324 -- Version with implicit type
3326 procedure Resolve (N : Node_Id) is
3328 Resolve (N, Etype (N));
3331 ---------------------
3332 -- Resolve_Actuals --
3333 ---------------------
3335 procedure Resolve_Actuals (N : Node_Id; Nam : Entity_Id) is
3336 Loc : constant Source_Ptr := Sloc (N);
3339 A_Typ : Entity_Id := Empty; -- init to avoid warning
3342 Prev : Node_Id := Empty;
3344 Real_F : Entity_Id := Empty; -- init to avoid warning
3346 Real_Subp : Entity_Id;
3347 -- If the subprogram being called is an inherited operation for
3348 -- a formal derived type in an instance, Real_Subp is the subprogram
3349 -- that will be called. It may have different formal names than the
3350 -- operation of the formal in the generic, so after actual is resolved
3351 -- the name of the actual in a named association must carry the name
3352 -- of the actual of the subprogram being called.
3354 procedure Check_Aliased_Parameter;
3355 -- Check rules on aliased parameters and related accessibility rules
3356 -- in (RM 3.10.2 (10.2-10.4)).
3358 procedure Check_Argument_Order;
3359 -- Performs a check for the case where the actuals are all simple
3360 -- identifiers that correspond to the formal names, but in the wrong
3361 -- order, which is considered suspicious and cause for a warning.
3363 procedure Check_Prefixed_Call;
3364 -- If the original node is an overloaded call in prefix notation,
3365 -- insert an 'Access or a dereference as needed over the first actual.
3366 -- Try_Object_Operation has already verified that there is a valid
3367 -- interpretation, but the form of the actual can only be determined
3368 -- once the primitive operation is identified.
3370 procedure Flag_Effectively_Volatile_Objects (Expr : Node_Id);
3371 -- Emit an error concerning the illegal usage of an effectively volatile
3372 -- object in interfering context (SPARK RM 7.13(12)).
3374 procedure Insert_Default;
3375 -- If the actual is missing in a call, insert in the actuals list
3376 -- an instance of the default expression. The insertion is always
3377 -- a named association.
3379 function Same_Ancestor (T1, T2 : Entity_Id) return Boolean;
3380 -- Check whether T1 and T2, or their full views, are derived from a
3381 -- common type. Used to enforce the restrictions on array conversions
3384 function Static_Concatenation (N : Node_Id) return Boolean;
3385 -- Predicate to determine whether an actual that is a concatenation
3386 -- will be evaluated statically and does not need a transient scope.
3387 -- This must be determined before the actual is resolved and expanded
3388 -- because if needed the transient scope must be introduced earlier.
3390 -----------------------------
3391 -- Check_Aliased_Parameter --
3392 -----------------------------
3394 procedure Check_Aliased_Parameter is
3395 Nominal_Subt : Entity_Id;
3398 if Is_Aliased (F) then
3399 if Is_Tagged_Type (A_Typ) then
3402 elsif Is_Aliased_View (A) then
3403 if Is_Constr_Subt_For_U_Nominal (A_Typ) then
3404 Nominal_Subt := Base_Type (A_Typ);
3406 Nominal_Subt := A_Typ;
3409 if Subtypes_Statically_Match (F_Typ, Nominal_Subt) then
3412 -- In a generic body assume the worst for generic formals:
3413 -- they can have a constrained partial view (AI05-041).
3415 elsif Has_Discriminants (F_Typ)
3416 and then not Is_Constrained (F_Typ)
3417 and then not Has_Constrained_Partial_View (F_Typ)
3418 and then not Is_Generic_Type (F_Typ)
3423 Error_Msg_NE ("untagged actual does not match "
3424 & "aliased formal&", A, F);
3428 Error_Msg_NE ("actual for aliased formal& must be "
3429 & "aliased object", A, F);
3432 if Ekind (Nam) = E_Procedure then
3435 elsif Ekind (Etype (Nam)) = E_Anonymous_Access_Type then
3436 if Nkind (Parent (N)) = N_Type_Conversion
3437 and then Type_Access_Level (Etype (Parent (N))) <
3438 Object_Access_Level (A)
3440 Error_Msg_N ("aliased actual has wrong accessibility", A);
3443 elsif Nkind (Parent (N)) = N_Qualified_Expression
3444 and then Nkind (Parent (Parent (N))) = N_Allocator
3445 and then Type_Access_Level (Etype (Parent (Parent (N)))) <
3446 Object_Access_Level (A)
3449 ("aliased actual in allocator has wrong accessibility", A);
3452 end Check_Aliased_Parameter;
3454 --------------------------
3455 -- Check_Argument_Order --
3456 --------------------------
3458 procedure Check_Argument_Order is
3460 -- Nothing to do if no parameters, or original node is neither a
3461 -- function call nor a procedure call statement (happens in the
3462 -- operator-transformed-to-function call case), or the call is to an
3463 -- operator symbol (which is usually in infix form), or the call does
3464 -- not come from source, or this warning is off.
3466 if not Warn_On_Parameter_Order
3467 or else No (Parameter_Associations (N))
3468 or else Nkind (Original_Node (N)) not in N_Subprogram_Call
3469 or else (Nkind (Name (N)) = N_Identifier
3470 and then Present (Entity (Name (N)))
3471 and then Nkind (Entity (Name (N))) =
3472 N_Defining_Operator_Symbol)
3473 or else not Comes_From_Source (N)
3479 Nargs : constant Nat := List_Length (Parameter_Associations (N));
3482 -- Nothing to do if only one parameter
3488 -- Here if at least two arguments
3491 Actuals : array (1 .. Nargs) of Node_Id;
3495 Wrong_Order : Boolean := False;
3496 -- Set True if an out of order case is found
3499 -- Collect identifier names of actuals, fail if any actual is
3500 -- not a simple identifier, and record max length of name.
3502 Actual := First (Parameter_Associations (N));
3503 for J in Actuals'Range loop
3504 if Nkind (Actual) /= N_Identifier then
3507 Actuals (J) := Actual;
3512 -- If we got this far, all actuals are identifiers and the list
3513 -- of their names is stored in the Actuals array.
3515 Formal := First_Formal (Nam);
3516 for J in Actuals'Range loop
3518 -- If we ran out of formals, that's odd, probably an error
3519 -- which will be detected elsewhere, but abandon the search.
3525 -- If name matches and is in order OK
3527 if Chars (Formal) = Chars (Actuals (J)) then
3531 -- If no match, see if it is elsewhere in list and if so
3532 -- flag potential wrong order if type is compatible.
3534 for K in Actuals'Range loop
3535 if Chars (Formal) = Chars (Actuals (K))
3537 Has_Compatible_Type (Actuals (K), Etype (Formal))
3539 Wrong_Order := True;
3549 <<Continue>> Next_Formal (Formal);
3552 -- If Formals left over, also probably an error, skip warning
3554 if Present (Formal) then
3558 -- Here we give the warning if something was out of order
3562 ("?P?actuals for this call may be in wrong order", N);
3566 end Check_Argument_Order;
3568 -------------------------
3569 -- Check_Prefixed_Call --
3570 -------------------------
3572 procedure Check_Prefixed_Call is
3573 Act : constant Node_Id := First_Actual (N);
3574 A_Type : constant Entity_Id := Etype (Act);
3575 F_Type : constant Entity_Id := Etype (First_Formal (Nam));
3576 Orig : constant Node_Id := Original_Node (N);
3580 -- Check whether the call is a prefixed call, with or without
3581 -- additional actuals.
3583 if Nkind (Orig) = N_Selected_Component
3585 (Nkind (Orig) = N_Indexed_Component
3586 and then Nkind (Prefix (Orig)) = N_Selected_Component
3587 and then Is_Entity_Name (Prefix (Prefix (Orig)))
3588 and then Is_Entity_Name (Act)
3589 and then Chars (Act) = Chars (Prefix (Prefix (Orig))))
3591 if Is_Access_Type (A_Type)
3592 and then not Is_Access_Type (F_Type)
3594 -- Introduce dereference on object in prefix
3597 Make_Explicit_Dereference (Sloc (Act),
3598 Prefix => Relocate_Node (Act));
3599 Rewrite (Act, New_A);
3602 elsif Is_Access_Type (F_Type)
3603 and then not Is_Access_Type (A_Type)
3605 -- Introduce an implicit 'Access in prefix
3607 if not Is_Aliased_View (Act) then
3609 ("object in prefixed call to& must be aliased "
3610 & "(RM 4.1.3 (13 1/2))",
3615 Make_Attribute_Reference (Loc,
3616 Attribute_Name => Name_Access,
3617 Prefix => Relocate_Node (Act)));
3622 end Check_Prefixed_Call;
3624 ---------------------------------------
3625 -- Flag_Effectively_Volatile_Objects --
3626 ---------------------------------------
3628 procedure Flag_Effectively_Volatile_Objects (Expr : Node_Id) is
3629 function Flag_Object (N : Node_Id) return Traverse_Result;
3630 -- Determine whether arbitrary node N denotes an effectively volatile
3631 -- object and if it does, emit an error.
3637 function Flag_Object (N : Node_Id) return Traverse_Result is
3641 -- Do not consider nested function calls because they have already
3642 -- been processed during their own resolution.
3644 if Nkind (N) = N_Function_Call then
3647 elsif Is_Entity_Name (N) and then Present (Entity (N)) then
3651 and then Is_Effectively_Volatile (Id)
3652 and then (Async_Writers_Enabled (Id)
3653 or else Effective_Reads_Enabled (Id))
3656 ("volatile object cannot appear in this context (SPARK "
3657 & "RM 7.1.3(11))", N);
3665 procedure Flag_Objects is new Traverse_Proc (Flag_Object);
3667 -- Start of processing for Flag_Effectively_Volatile_Objects
3670 Flag_Objects (Expr);
3671 end Flag_Effectively_Volatile_Objects;
3673 --------------------
3674 -- Insert_Default --
3675 --------------------
3677 procedure Insert_Default is
3682 -- Missing argument in call, nothing to insert
3684 if No (Default_Value (F)) then
3688 -- Note that we do a full New_Copy_Tree, so that any associated
3689 -- Itypes are properly copied. This may not be needed any more,
3690 -- but it does no harm as a safety measure. Defaults of a generic
3691 -- formal may be out of bounds of the corresponding actual (see
3692 -- cc1311b) and an additional check may be required.
3697 New_Scope => Current_Scope,
3700 -- Propagate dimension information, if any.
3702 Copy_Dimensions (Default_Value (F), Actval);
3704 if Is_Concurrent_Type (Scope (Nam))
3705 and then Has_Discriminants (Scope (Nam))
3707 Replace_Actual_Discriminants (N, Actval);
3710 if Is_Overloadable (Nam)
3711 and then Present (Alias (Nam))
3713 if Base_Type (Etype (F)) /= Base_Type (Etype (Actval))
3714 and then not Is_Tagged_Type (Etype (F))
3716 -- If default is a real literal, do not introduce a
3717 -- conversion whose effect may depend on the run-time
3718 -- size of universal real.
3720 if Nkind (Actval) = N_Real_Literal then
3721 Set_Etype (Actval, Base_Type (Etype (F)));
3723 Actval := Unchecked_Convert_To (Etype (F), Actval);
3727 if Is_Scalar_Type (Etype (F)) then
3728 Enable_Range_Check (Actval);
3731 Set_Parent (Actval, N);
3733 -- Resolve aggregates with their base type, to avoid scope
3734 -- anomalies: the subtype was first built in the subprogram
3735 -- declaration, and the current call may be nested.
3737 if Nkind (Actval) = N_Aggregate then
3738 Analyze_And_Resolve (Actval, Etype (F));
3740 Analyze_And_Resolve (Actval, Etype (Actval));
3744 Set_Parent (Actval, N);
3746 -- See note above concerning aggregates
3748 if Nkind (Actval) = N_Aggregate
3749 and then Has_Discriminants (Etype (Actval))
3751 Analyze_And_Resolve (Actval, Base_Type (Etype (Actval)));
3753 -- Resolve entities with their own type, which may differ from
3754 -- the type of a reference in a generic context (the view
3755 -- swapping mechanism did not anticipate the re-analysis of
3756 -- default values in calls).
3758 elsif Is_Entity_Name (Actval) then
3759 Analyze_And_Resolve (Actval, Etype (Entity (Actval)));
3762 Analyze_And_Resolve (Actval, Etype (Actval));
3766 -- If default is a tag indeterminate function call, propagate tag
3767 -- to obtain proper dispatching.
3769 if Is_Controlling_Formal (F)
3770 and then Nkind (Default_Value (F)) = N_Function_Call
3772 Set_Is_Controlling_Actual (Actval);
3776 -- If the default expression raises constraint error, then just
3777 -- silently replace it with an N_Raise_Constraint_Error node, since
3778 -- we already gave the warning on the subprogram spec. If node is
3779 -- already a Raise_Constraint_Error leave as is, to prevent loops in
3780 -- the warnings removal machinery.
3782 if Raises_Constraint_Error (Actval)
3783 and then Nkind (Actval) /= N_Raise_Constraint_Error
3786 Make_Raise_Constraint_Error (Loc,
3787 Reason => CE_Range_Check_Failed));
3789 Set_Raises_Constraint_Error (Actval);
3790 Set_Etype (Actval, Etype (F));
3794 Make_Parameter_Association (Loc,
3795 Explicit_Actual_Parameter => Actval,
3796 Selector_Name => Make_Identifier (Loc, Chars (F)));
3798 -- Case of insertion is first named actual
3801 or else Nkind (Parent (Prev)) /= N_Parameter_Association
3803 Set_Next_Named_Actual (Assoc, First_Named_Actual (N));
3804 Set_First_Named_Actual (N, Actval);
3807 if No (Parameter_Associations (N)) then
3808 Set_Parameter_Associations (N, New_List (Assoc));
3810 Append (Assoc, Parameter_Associations (N));
3814 Insert_After (Prev, Assoc);
3817 -- Case of insertion is not first named actual
3820 Set_Next_Named_Actual
3821 (Assoc, Next_Named_Actual (Parent (Prev)));
3822 Set_Next_Named_Actual (Parent (Prev), Actval);
3823 Append (Assoc, Parameter_Associations (N));
3826 Mark_Rewrite_Insertion (Assoc);
3827 Mark_Rewrite_Insertion (Actval);
3836 function Same_Ancestor (T1, T2 : Entity_Id) return Boolean is
3837 FT1 : Entity_Id := T1;
3838 FT2 : Entity_Id := T2;
3841 if Is_Private_Type (T1)
3842 and then Present (Full_View (T1))
3844 FT1 := Full_View (T1);
3847 if Is_Private_Type (T2)
3848 and then Present (Full_View (T2))
3850 FT2 := Full_View (T2);
3853 return Root_Type (Base_Type (FT1)) = Root_Type (Base_Type (FT2));
3856 --------------------------
3857 -- Static_Concatenation --
3858 --------------------------
3860 function Static_Concatenation (N : Node_Id) return Boolean is
3863 when N_String_Literal =>
3868 -- Concatenation is static when both operands are static and
3869 -- the concatenation operator is a predefined one.
3871 return Scope (Entity (N)) = Standard_Standard
3873 Static_Concatenation (Left_Opnd (N))
3875 Static_Concatenation (Right_Opnd (N));
3878 if Is_Entity_Name (N) then
3880 Ent : constant Entity_Id := Entity (N);
3882 return Ekind (Ent) = E_Constant
3883 and then Present (Constant_Value (Ent))
3885 Is_OK_Static_Expression (Constant_Value (Ent));
3892 end Static_Concatenation;
3894 -- Start of processing for Resolve_Actuals
3897 Check_Argument_Order;
3899 if Is_Overloadable (Nam)
3900 and then Is_Inherited_Operation (Nam)
3901 and then In_Instance
3902 and then Present (Alias (Nam))
3903 and then Present (Overridden_Operation (Alias (Nam)))
3905 Real_Subp := Alias (Nam);
3910 if Present (First_Actual (N)) then
3911 Check_Prefixed_Call;
3914 A := First_Actual (N);
3915 F := First_Formal (Nam);
3917 if Present (Real_Subp) then
3918 Real_F := First_Formal (Real_Subp);
3921 while Present (F) loop
3922 if No (A) and then Needs_No_Actuals (Nam) then
3925 -- If we have an error in any actual or formal, indicated by a type
3926 -- of Any_Type, then abandon resolution attempt, and set result type
3927 -- to Any_Type. Skip this if the actual is a Raise_Expression, whose
3928 -- type is imposed from context.
3930 elsif (Present (A) and then Etype (A) = Any_Type)
3931 or else Etype (F) = Any_Type
3933 if Nkind (A) /= N_Raise_Expression then
3934 Set_Etype (N, Any_Type);
3939 -- Case where actual is present
3941 -- If the actual is an entity, generate a reference to it now. We
3942 -- do this before the actual is resolved, because a formal of some
3943 -- protected subprogram, or a task discriminant, will be rewritten
3944 -- during expansion, and the source entity reference may be lost.
3947 and then Is_Entity_Name (A)
3948 and then Comes_From_Source (A)
3950 -- Annotate the tree by creating a variable reference marker when
3951 -- the actual denotes a variable reference, in case the reference
3952 -- is folded or optimized away. The variable reference marker is
3953 -- automatically saved for later examination by the ABE Processing
3954 -- phase. The status of the reference is set as follows:
3958 -- write IN OUT, OUT
3960 if Needs_Variable_Reference_Marker
3964 Build_Variable_Reference_Marker
3966 Read => Ekind (F) /= E_Out_Parameter,
3967 Write => Ekind (F) /= E_In_Parameter);
3970 Orig_A := Entity (A);
3972 if Present (Orig_A) then
3973 if Is_Formal (Orig_A)
3974 and then Ekind (F) /= E_In_Parameter
3976 Generate_Reference (Orig_A, A, 'm');
3978 elsif not Is_Overloaded (A) then
3979 if Ekind (F) /= E_Out_Parameter then
3980 Generate_Reference (Orig_A, A);
3982 -- RM 6.4.1(12): For an out parameter that is passed by
3983 -- copy, the formal parameter object is created, and:
3985 -- * For an access type, the formal parameter is initialized
3986 -- from the value of the actual, without checking that the
3987 -- value satisfies any constraint, any predicate, or any
3988 -- exclusion of the null value.
3990 -- * For a scalar type that has the Default_Value aspect
3991 -- specified, the formal parameter is initialized from the
3992 -- value of the actual, without checking that the value
3993 -- satisfies any constraint or any predicate.
3994 -- I do not understand why this case is included??? this is
3995 -- not a case where an OUT parameter is treated as IN OUT.
3997 -- * For a composite type with discriminants or that has
3998 -- implicit initial values for any subcomponents, the
3999 -- behavior is as for an in out parameter passed by copy.
4001 -- Hence for these cases we generate the read reference now
4002 -- (the write reference will be generated later by
4003 -- Note_Possible_Modification).
4005 elsif Is_By_Copy_Type (Etype (F))
4007 (Is_Access_Type (Etype (F))
4009 (Is_Scalar_Type (Etype (F))
4011 Present (Default_Aspect_Value (Etype (F))))
4013 (Is_Composite_Type (Etype (F))
4014 and then (Has_Discriminants (Etype (F))
4015 or else Is_Partially_Initialized_Type
4018 Generate_Reference (Orig_A, A);
4025 and then (Nkind (Parent (A)) /= N_Parameter_Association
4026 or else Chars (Selector_Name (Parent (A))) = Chars (F))
4028 -- If style checking mode on, check match of formal name
4031 if Nkind (Parent (A)) = N_Parameter_Association then
4032 Check_Identifier (Selector_Name (Parent (A)), F);
4036 -- If the formal is Out or In_Out, do not resolve and expand the
4037 -- conversion, because it is subsequently expanded into explicit
4038 -- temporaries and assignments. However, the object of the
4039 -- conversion can be resolved. An exception is the case of tagged
4040 -- type conversion with a class-wide actual. In that case we want
4041 -- the tag check to occur and no temporary will be needed (no
4042 -- representation change can occur) and the parameter is passed by
4043 -- reference, so we go ahead and resolve the type conversion.
4044 -- Another exception is the case of reference to component or
4045 -- subcomponent of a bit-packed array, in which case we want to
4046 -- defer expansion to the point the in and out assignments are
4049 if Ekind (F) /= E_In_Parameter
4050 and then Nkind (A) = N_Type_Conversion
4051 and then not Is_Class_Wide_Type (Etype (Expression (A)))
4052 and then not Is_Interface (Etype (A))
4054 if Ekind (F) = E_In_Out_Parameter
4055 and then Is_Array_Type (Etype (F))
4057 -- In a view conversion, the conversion must be legal in
4058 -- both directions, and thus both component types must be
4059 -- aliased, or neither (4.6 (8)).
4061 -- The extra rule in 4.6 (24.9.2) seems unduly restrictive:
4062 -- the privacy requirement should not apply to generic
4063 -- types, and should be checked in an instance. ARG query
4066 if Has_Aliased_Components (Etype (Expression (A))) /=
4067 Has_Aliased_Components (Etype (F))
4070 ("both component types in a view conversion must be"
4071 & " aliased, or neither", A);
4073 -- Comment here??? what set of cases???
4076 not Same_Ancestor (Etype (F), Etype (Expression (A)))
4078 -- Check view conv between unrelated by ref array types
4080 if Is_By_Reference_Type (Etype (F))
4081 or else Is_By_Reference_Type (Etype (Expression (A)))
4084 ("view conversion between unrelated by reference "
4085 & "array types not allowed (\'A'I-00246)", A);
4087 -- In Ada 2005 mode, check view conversion component
4088 -- type cannot be private, tagged, or volatile. Note
4089 -- that we only apply this to source conversions. The
4090 -- generated code can contain conversions which are
4091 -- not subject to this test, and we cannot extract the
4092 -- component type in such cases since it is not present.
4094 elsif Comes_From_Source (A)
4095 and then Ada_Version >= Ada_2005
4098 Comp_Type : constant Entity_Id :=
4100 (Etype (Expression (A)));
4102 if (Is_Private_Type (Comp_Type)
4103 and then not Is_Generic_Type (Comp_Type))
4104 or else Is_Tagged_Type (Comp_Type)
4105 or else Is_Volatile (Comp_Type)
4108 ("component type of a view conversion cannot"
4109 & " be private, tagged, or volatile"
4118 -- Resolve expression if conversion is all OK
4120 if (Conversion_OK (A)
4121 or else Valid_Conversion (A, Etype (A), Expression (A)))
4122 and then not Is_Ref_To_Bit_Packed_Array (Expression (A))
4124 Resolve (Expression (A));
4127 -- If the actual is a function call that returns a limited
4128 -- unconstrained object that needs finalization, create a
4129 -- transient scope for it, so that it can receive the proper
4130 -- finalization list.
4132 elsif Expander_Active
4133 and then Nkind (A) = N_Function_Call
4134 and then Is_Limited_Record (Etype (F))
4135 and then not Is_Constrained (Etype (F))
4136 and then (Needs_Finalization (Etype (F))
4137 or else Has_Task (Etype (F)))
4139 Establish_Transient_Scope (A, Manage_Sec_Stack => False);
4140 Resolve (A, Etype (F));
4142 -- A small optimization: if one of the actuals is a concatenation
4143 -- create a block around a procedure call to recover stack space.
4144 -- This alleviates stack usage when several procedure calls in
4145 -- the same statement list use concatenation. We do not perform
4146 -- this wrapping for code statements, where the argument is a
4147 -- static string, and we want to preserve warnings involving
4148 -- sequences of such statements.
4150 elsif Expander_Active
4151 and then Nkind (A) = N_Op_Concat
4152 and then Nkind (N) = N_Procedure_Call_Statement
4153 and then not (Is_Intrinsic_Subprogram (Nam)
4154 and then Chars (Nam) = Name_Asm)
4155 and then not Static_Concatenation (A)
4157 Establish_Transient_Scope (A, Manage_Sec_Stack => False);
4158 Resolve (A, Etype (F));
4161 if Nkind (A) = N_Type_Conversion
4162 and then Is_Array_Type (Etype (F))
4163 and then not Same_Ancestor (Etype (F), Etype (Expression (A)))
4165 (Is_Limited_Type (Etype (F))
4166 or else Is_Limited_Type (Etype (Expression (A))))
4169 ("conversion between unrelated limited array types not "
4170 & "allowed ('A'I-00246)", A);
4172 if Is_Limited_Type (Etype (F)) then
4173 Explain_Limited_Type (Etype (F), A);
4176 if Is_Limited_Type (Etype (Expression (A))) then
4177 Explain_Limited_Type (Etype (Expression (A)), A);
4181 -- (Ada 2005: AI-251): If the actual is an allocator whose
4182 -- directly designated type is a class-wide interface, we build
4183 -- an anonymous access type to use it as the type of the
4184 -- allocator. Later, when the subprogram call is expanded, if
4185 -- the interface has a secondary dispatch table the expander
4186 -- will add a type conversion to force the correct displacement
4189 if Nkind (A) = N_Allocator then
4191 DDT : constant Entity_Id :=
4192 Directly_Designated_Type (Base_Type (Etype (F)));
4195 -- Displace the pointer to the object to reference its
4196 -- secondary dispatch table.
4198 if Is_Class_Wide_Type (DDT)
4199 and then Is_Interface (DDT)
4201 Rewrite (A, Convert_To (Etype (F), Relocate_Node (A)));
4202 Analyze_And_Resolve (A, Etype (F),
4203 Suppress => Access_Check);
4206 -- Ada 2005, AI-162:If the actual is an allocator, the
4207 -- innermost enclosing statement is the master of the
4208 -- created object. This needs to be done with expansion
4209 -- enabled only, otherwise the transient scope will not
4210 -- be removed in the expansion of the wrapped construct.
4213 and then (Needs_Finalization (DDT)
4214 or else Has_Task (DDT))
4216 Establish_Transient_Scope
4217 (A, Manage_Sec_Stack => False);
4221 if Ekind (Etype (F)) = E_Anonymous_Access_Type then
4222 Check_Restriction (No_Access_Parameter_Allocators, A);
4226 -- (Ada 2005): The call may be to a primitive operation of a
4227 -- tagged synchronized type, declared outside of the type. In
4228 -- this case the controlling actual must be converted to its
4229 -- corresponding record type, which is the formal type. The
4230 -- actual may be a subtype, either because of a constraint or
4231 -- because it is a generic actual, so use base type to locate
4234 F_Typ := Base_Type (Etype (F));
4236 if Is_Tagged_Type (F_Typ)
4237 and then (Is_Concurrent_Type (F_Typ)
4238 or else Is_Concurrent_Record_Type (F_Typ))
4240 -- If the actual is overloaded, look for an interpretation
4241 -- that has a synchronized type.
4243 if not Is_Overloaded (A) then
4244 A_Typ := Base_Type (Etype (A));
4248 Index : Interp_Index;
4252 Get_First_Interp (A, Index, It);
4253 while Present (It.Typ) loop
4254 if Is_Concurrent_Type (It.Typ)
4255 or else Is_Concurrent_Record_Type (It.Typ)
4257 A_Typ := Base_Type (It.Typ);
4261 Get_Next_Interp (Index, It);
4267 Full_A_Typ : Entity_Id;
4270 if Present (Full_View (A_Typ)) then
4271 Full_A_Typ := Base_Type (Full_View (A_Typ));
4273 Full_A_Typ := A_Typ;
4276 -- Tagged synchronized type (case 1): the actual is a
4279 if Is_Concurrent_Type (A_Typ)
4280 and then Corresponding_Record_Type (A_Typ) = F_Typ
4283 Unchecked_Convert_To
4284 (Corresponding_Record_Type (A_Typ), A));
4285 Resolve (A, Etype (F));
4287 -- Tagged synchronized type (case 2): the formal is a
4290 elsif Ekind (Full_A_Typ) = E_Record_Type
4292 (Corresponding_Concurrent_Type (Full_A_Typ))
4293 and then Is_Concurrent_Type (F_Typ)
4294 and then Present (Corresponding_Record_Type (F_Typ))
4295 and then Full_A_Typ = Corresponding_Record_Type (F_Typ)
4297 Resolve (A, Corresponding_Record_Type (F_Typ));
4302 Resolve (A, Etype (F));
4306 -- Not a synchronized operation
4309 Resolve (A, Etype (F));
4316 -- An actual cannot be an untagged formal incomplete type
4318 if Ekind (A_Typ) = E_Incomplete_Type
4319 and then not Is_Tagged_Type (A_Typ)
4320 and then Is_Generic_Type (A_Typ)
4323 ("invalid use of untagged formal incomplete type", A);
4326 if Comes_From_Source (Original_Node (N))
4327 and then Nkind_In (Original_Node (N), N_Function_Call,
4328 N_Procedure_Call_Statement)
4330 -- In formal mode, check that actual parameters matching
4331 -- formals of tagged types are objects (or ancestor type
4332 -- conversions of objects), not general expressions.
4334 if Is_Actual_Tagged_Parameter (A) then
4335 if Is_SPARK_05_Object_Reference (A) then
4338 elsif Nkind (A) = N_Type_Conversion then
4340 Operand : constant Node_Id := Expression (A);
4341 Operand_Typ : constant Entity_Id := Etype (Operand);
4342 Target_Typ : constant Entity_Id := A_Typ;
4345 if not Is_SPARK_05_Object_Reference (Operand) then
4346 Check_SPARK_05_Restriction
4347 ("object required", Operand);
4349 -- In formal mode, the only view conversions are those
4350 -- involving ancestor conversion of an extended type.
4353 (Is_Tagged_Type (Target_Typ)
4354 and then not Is_Class_Wide_Type (Target_Typ)
4355 and then Is_Tagged_Type (Operand_Typ)
4356 and then not Is_Class_Wide_Type (Operand_Typ)
4357 and then Is_Ancestor (Target_Typ, Operand_Typ))
4360 (F, E_Out_Parameter, E_In_Out_Parameter)
4362 Check_SPARK_05_Restriction
4363 ("ancestor conversion is the only permitted "
4364 & "view conversion", A);
4366 Check_SPARK_05_Restriction
4367 ("ancestor conversion required", A);
4376 Check_SPARK_05_Restriction ("object required", A);
4379 -- In formal mode, the only view conversions are those
4380 -- involving ancestor conversion of an extended type.
4382 elsif Nkind (A) = N_Type_Conversion
4383 and then Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter)
4385 Check_SPARK_05_Restriction
4386 ("ancestor conversion is the only permitted view "
4391 -- has warnings suppressed, then we reset Never_Set_In_Source for
4392 -- the calling entity. The reason for this is to catch cases like
4393 -- GNAT.Spitbol.Patterns.Vstring_Var where the called subprogram
4394 -- uses trickery to modify an IN parameter.
4396 if Ekind (F) = E_In_Parameter
4397 and then Is_Entity_Name (A)
4398 and then Present (Entity (A))
4399 and then Ekind (Entity (A)) = E_Variable
4400 and then Has_Warnings_Off (F_Typ)
4402 Set_Never_Set_In_Source (Entity (A), False);
4405 -- Perform error checks for IN and IN OUT parameters
4407 if Ekind (F) /= E_Out_Parameter then
4409 -- Check unset reference. For scalar parameters, it is clearly
4410 -- wrong to pass an uninitialized value as either an IN or
4411 -- IN-OUT parameter. For composites, it is also clearly an
4412 -- error to pass a completely uninitialized value as an IN
4413 -- parameter, but the case of IN OUT is trickier. We prefer
4414 -- not to give a warning here. For example, suppose there is
4415 -- a routine that sets some component of a record to False.
4416 -- It is perfectly reasonable to make this IN-OUT and allow
4417 -- either initialized or uninitialized records to be passed
4420 -- For partially initialized composite values, we also avoid
4421 -- warnings, since it is quite likely that we are passing a
4422 -- partially initialized value and only the initialized fields
4423 -- will in fact be read in the subprogram.
4425 if Is_Scalar_Type (A_Typ)
4426 or else (Ekind (F) = E_In_Parameter
4427 and then not Is_Partially_Initialized_Type (A_Typ))
4429 Check_Unset_Reference (A);
4432 -- In Ada 83 we cannot pass an OUT parameter as an IN or IN OUT
4433 -- actual to a nested call, since this constitutes a reading of
4434 -- the parameter, which is not allowed.
4436 if Ada_Version = Ada_83
4437 and then Is_Entity_Name (A)
4438 and then Ekind (Entity (A)) = E_Out_Parameter
4440 Error_Msg_N ("(Ada 83) illegal reading of out parameter", A);
4444 -- In -gnatd.q mode, forget that a given array is constant when
4445 -- it is passed as an IN parameter to a foreign-convention
4446 -- subprogram. This is in case the subprogram evilly modifies the
4447 -- object. Of course, correct code would use IN OUT.
4450 and then Ekind (F) = E_In_Parameter
4451 and then Has_Foreign_Convention (Nam)
4452 and then Is_Array_Type (F_Typ)
4453 and then Nkind (A) in N_Has_Entity
4454 and then Present (Entity (A))
4456 Set_Is_True_Constant (Entity (A), False);
4459 -- Case of OUT or IN OUT parameter
4461 if Ekind (F) /= E_In_Parameter then
4463 -- For an Out parameter, check for useless assignment. Note
4464 -- that we can't set Last_Assignment this early, because we may
4465 -- kill current values in Resolve_Call, and that call would
4466 -- clobber the Last_Assignment field.
4468 -- Note: call Warn_On_Useless_Assignment before doing the check
4469 -- below for Is_OK_Variable_For_Out_Formal so that the setting
4470 -- of Referenced_As_LHS/Referenced_As_Out_Formal properly
4471 -- reflects the last assignment, not this one.
4473 if Ekind (F) = E_Out_Parameter then
4474 if Warn_On_Modified_As_Out_Parameter (F)
4475 and then Is_Entity_Name (A)
4476 and then Present (Entity (A))
4477 and then Comes_From_Source (N)
4479 Warn_On_Useless_Assignment (Entity (A), A);
4483 -- Validate the form of the actual. Note that the call to
4484 -- Is_OK_Variable_For_Out_Formal generates the required
4485 -- reference in this case.
4487 -- A call to an initialization procedure for an aggregate
4488 -- component may initialize a nested component of a constant
4489 -- designated object. In this context the object is variable.
4491 if not Is_OK_Variable_For_Out_Formal (A)
4492 and then not Is_Init_Proc (Nam)
4494 Error_Msg_NE ("actual for& must be a variable", A, F);
4496 if Is_Subprogram (Current_Scope) then
4497 if Is_Invariant_Procedure (Current_Scope)
4498 or else Is_Partial_Invariant_Procedure (Current_Scope)
4501 ("function used in invariant cannot modify its "
4504 elsif Is_Predicate_Function (Current_Scope) then
4506 ("function used in predicate cannot modify its "
4512 -- What's the following about???
4514 if Is_Entity_Name (A) then
4515 Kill_Checks (Entity (A));
4521 if A_Typ = Any_Type then
4522 Set_Etype (N, Any_Type);
4526 -- Apply appropriate constraint/predicate checks for IN [OUT] case
4528 if Ekind_In (F, E_In_Parameter, E_In_Out_Parameter) then
4530 -- Apply predicate tests except in certain special cases. Note
4531 -- that it might be more consistent to apply these only when
4532 -- expansion is active (in Exp_Ch6.Expand_Actuals), as we do
4533 -- for the outbound predicate tests ??? In any case indicate
4534 -- the function being called, for better warnings if the call
4535 -- leads to an infinite recursion.
4537 if Predicate_Tests_On_Arguments (Nam) then
4538 Apply_Predicate_Check (A, F_Typ, Nam);
4541 -- Apply required constraint checks
4543 if Is_Scalar_Type (A_Typ) then
4544 Apply_Scalar_Range_Check (A, F_Typ);
4546 elsif Is_Array_Type (A_Typ) then
4547 Apply_Length_Check (A, F_Typ);
4549 elsif Is_Record_Type (F_Typ)
4550 and then Has_Discriminants (F_Typ)
4551 and then Is_Constrained (F_Typ)
4552 and then (not Is_Derived_Type (F_Typ)
4553 or else Comes_From_Source (Nam))
4555 Apply_Discriminant_Check (A, F_Typ);
4557 -- For view conversions of a discriminated object, apply
4558 -- check to object itself, the conversion alreay has the
4561 if Nkind (A) = N_Type_Conversion
4562 and then Is_Constrained (Etype (Expression (A)))
4564 Apply_Discriminant_Check (Expression (A), F_Typ);
4567 elsif Is_Access_Type (F_Typ)
4568 and then Is_Array_Type (Designated_Type (F_Typ))
4569 and then Is_Constrained (Designated_Type (F_Typ))
4571 Apply_Length_Check (A, F_Typ);
4573 elsif Is_Access_Type (F_Typ)
4574 and then Has_Discriminants (Designated_Type (F_Typ))
4575 and then Is_Constrained (Designated_Type (F_Typ))
4577 Apply_Discriminant_Check (A, F_Typ);
4580 Apply_Range_Check (A, F_Typ);
4583 -- Ada 2005 (AI-231): Note that the controlling parameter case
4584 -- already existed in Ada 95, which is partially checked
4585 -- elsewhere (see Checks), and we don't want the warning
4586 -- message to differ.
4588 if Is_Access_Type (F_Typ)
4589 and then Can_Never_Be_Null (F_Typ)
4590 and then Known_Null (A)
4592 if Is_Controlling_Formal (F) then
4593 Apply_Compile_Time_Constraint_Error
4595 Msg => "null value not allowed here??",
4596 Reason => CE_Access_Check_Failed);
4598 elsif Ada_Version >= Ada_2005 then
4599 Apply_Compile_Time_Constraint_Error
4601 Msg => "(Ada 2005) null not allowed in "
4602 & "null-excluding formal??",
4603 Reason => CE_Null_Not_Allowed);
4608 -- Checks for OUT parameters and IN OUT parameters
4610 if Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter) then
4612 -- If there is a type conversion, make sure the return value
4613 -- meets the constraints of the variable before the conversion.
4615 if Nkind (A) = N_Type_Conversion then
4616 if Is_Scalar_Type (A_Typ) then
4618 -- Special case here tailored to Exp_Ch6.Is_Legal_Copy,
4619 -- which would prevent the check from being generated.
4620 -- This is for Starlet only though, so long obsolete.
4622 if Mechanism (F) = By_Reference
4623 and then Is_Valued_Procedure (Nam)
4627 Apply_Scalar_Range_Check
4628 (Expression (A), Etype (Expression (A)), A_Typ);
4631 -- In addition the return value must meet the constraints
4632 -- of the object type (see the comment below).
4634 Apply_Scalar_Range_Check (A, A_Typ, F_Typ);
4638 (Expression (A), Etype (Expression (A)), A_Typ);
4641 -- If no conversion, apply scalar range checks and length check
4642 -- based on the subtype of the actual (NOT that of the formal).
4643 -- This indicates that the check takes place on return from the
4644 -- call. During expansion the required constraint checks are
4645 -- inserted. In GNATprove mode, in the absence of expansion,
4646 -- the flag indicates that the returned value is valid.
4649 if Is_Scalar_Type (F_Typ) then
4650 Apply_Scalar_Range_Check (A, A_Typ, F_Typ);
4652 elsif Is_Array_Type (F_Typ)
4653 and then Ekind (F) = E_Out_Parameter
4655 Apply_Length_Check (A, F_Typ);
4658 Apply_Range_Check (A, A_Typ, F_Typ);
4662 -- Note: we do not apply the predicate checks for the case of
4663 -- OUT and IN OUT parameters. They are instead applied in the
4664 -- Expand_Actuals routine in Exp_Ch6.
4667 -- An actual associated with an access parameter is implicitly
4668 -- converted to the anonymous access type of the formal and must
4669 -- satisfy the legality checks for access conversions.
4671 if Ekind (F_Typ) = E_Anonymous_Access_Type then
4672 if not Valid_Conversion (A, F_Typ, A) then
4674 ("invalid implicit conversion for access parameter", A);
4677 -- If the actual is an access selected component of a variable,
4678 -- the call may modify its designated object. It is reasonable
4679 -- to treat this as a potential modification of the enclosing
4680 -- record, to prevent spurious warnings that it should be
4681 -- declared as a constant, because intuitively programmers
4682 -- regard the designated subcomponent as part of the record.
4684 if Nkind (A) = N_Selected_Component
4685 and then Is_Entity_Name (Prefix (A))
4686 and then not Is_Constant_Object (Entity (Prefix (A)))
4688 Note_Possible_Modification (A, Sure => False);
4692 -- Check bad case of atomic/volatile argument (RM C.6(12))
4694 if Is_By_Reference_Type (Etype (F))
4695 and then Comes_From_Source (N)
4697 if Is_Atomic_Object (A)
4698 and then not Is_Atomic (Etype (F))
4701 ("cannot pass atomic argument to non-atomic formal&",
4704 elsif Is_Volatile_Object (A)
4705 and then not Is_Volatile (Etype (F))
4708 ("cannot pass volatile argument to non-volatile formal&",
4713 -- Check that subprograms don't have improper controlling
4714 -- arguments (RM 3.9.2 (9)).
4716 -- A primitive operation may have an access parameter of an
4717 -- incomplete tagged type, but a dispatching call is illegal
4718 -- if the type is still incomplete.
4720 if Is_Controlling_Formal (F) then
4721 Set_Is_Controlling_Actual (A);
4723 if Ekind (Etype (F)) = E_Anonymous_Access_Type then
4725 Desig : constant Entity_Id := Designated_Type (Etype (F));
4727 if Ekind (Desig) = E_Incomplete_Type
4728 and then No (Full_View (Desig))
4729 and then No (Non_Limited_View (Desig))
4732 ("premature use of incomplete type& "
4733 & "in dispatching call", A, Desig);
4738 elsif Nkind (A) = N_Explicit_Dereference then
4739 Validate_Remote_Access_To_Class_Wide_Type (A);
4742 -- Apply legality rule 3.9.2 (9/1)
4744 if (Is_Class_Wide_Type (A_Typ) or else Is_Dynamically_Tagged (A))
4745 and then not Is_Class_Wide_Type (F_Typ)
4746 and then not Is_Controlling_Formal (F)
4747 and then not In_Instance
4749 Error_Msg_N ("class-wide argument not allowed here!", A);
4751 if Is_Subprogram (Nam) and then Comes_From_Source (Nam) then
4752 Error_Msg_Node_2 := F_Typ;
4754 ("& is not a dispatching operation of &!", A, Nam);
4757 -- Apply the checks described in 3.10.2(27): if the context is a
4758 -- specific access-to-object, the actual cannot be class-wide.
4759 -- Use base type to exclude access_to_subprogram cases.
4761 elsif Is_Access_Type (A_Typ)
4762 and then Is_Access_Type (F_Typ)
4763 and then not Is_Access_Subprogram_Type (Base_Type (F_Typ))
4764 and then (Is_Class_Wide_Type (Designated_Type (A_Typ))
4765 or else (Nkind (A) = N_Attribute_Reference
4767 Is_Class_Wide_Type (Etype (Prefix (A)))))
4768 and then not Is_Class_Wide_Type (Designated_Type (F_Typ))
4769 and then not Is_Controlling_Formal (F)
4771 -- Disable these checks for call to imported C++ subprograms
4774 (Is_Entity_Name (Name (N))
4775 and then Is_Imported (Entity (Name (N)))
4776 and then Convention (Entity (Name (N))) = Convention_CPP)
4779 ("access to class-wide argument not allowed here!", A);
4781 if Is_Subprogram (Nam) and then Comes_From_Source (Nam) then
4782 Error_Msg_Node_2 := Designated_Type (F_Typ);
4784 ("& is not a dispatching operation of &!", A, Nam);
4788 Check_Aliased_Parameter;
4792 -- If it is a named association, treat the selector_name as a
4793 -- proper identifier, and mark the corresponding entity.
4795 if Nkind (Parent (A)) = N_Parameter_Association
4797 -- Ignore reference in SPARK mode, as it refers to an entity not
4798 -- in scope at the point of reference, so the reference should
4799 -- be ignored for computing effects of subprograms.
4801 and then not GNATprove_Mode
4803 -- If subprogram is overridden, use name of formal that
4806 if Present (Real_Subp) then
4807 Set_Entity (Selector_Name (Parent (A)), Real_F);
4808 Set_Etype (Selector_Name (Parent (A)), Etype (Real_F));
4811 Set_Entity (Selector_Name (Parent (A)), F);
4812 Generate_Reference (F, Selector_Name (Parent (A)));
4813 Set_Etype (Selector_Name (Parent (A)), F_Typ);
4814 Generate_Reference (F_Typ, N, ' ');
4820 if Ekind (F) /= E_Out_Parameter then
4821 Check_Unset_Reference (A);
4824 -- The following checks are only relevant when SPARK_Mode is on as
4825 -- they are not standard Ada legality rule. Internally generated
4826 -- temporaries are ignored.
4828 if SPARK_Mode = On and then Comes_From_Source (A) then
4830 -- An effectively volatile object may act as an actual when the
4831 -- corresponding formal is of a non-scalar effectively volatile
4832 -- type (SPARK RM 7.1.3(11)).
4834 if not Is_Scalar_Type (Etype (F))
4835 and then Is_Effectively_Volatile (Etype (F))
4839 -- An effectively volatile object may act as an actual in a
4840 -- call to an instance of Unchecked_Conversion.
4841 -- (SPARK RM 7.1.3(11)).
4843 elsif Is_Unchecked_Conversion_Instance (Nam) then
4846 -- The actual denotes an object
4848 elsif Is_Effectively_Volatile_Object (A) then
4850 ("volatile object cannot act as actual in a call (SPARK "
4851 & "RM 7.1.3(11))", A);
4853 -- Otherwise the actual denotes an expression. Inspect the
4854 -- expression and flag each effectively volatile object with
4855 -- enabled property Async_Writers or Effective_Reads as illegal
4856 -- because it apprears within an interfering context. Note that
4857 -- this is usually done in Resolve_Entity_Name, but when the
4858 -- effectively volatile object appears as an actual in a call,
4859 -- the call must be resolved first.
4862 Flag_Effectively_Volatile_Objects (A);
4865 -- An effectively volatile variable cannot act as an actual
4866 -- parameter in a procedure call when the variable has enabled
4867 -- property Effective_Reads and the corresponding formal is of
4868 -- mode IN (SPARK RM 7.1.3(10)).
4870 if Ekind (Nam) = E_Procedure
4871 and then Ekind (F) = E_In_Parameter
4872 and then Is_Entity_Name (A)
4876 if Ekind (A_Id) = E_Variable
4877 and then Is_Effectively_Volatile (Etype (A_Id))
4878 and then Effective_Reads_Enabled (A_Id)
4881 ("effectively volatile variable & cannot appear as "
4882 & "actual in procedure call", A, A_Id);
4884 Error_Msg_Name_1 := Name_Effective_Reads;
4885 Error_Msg_N ("\\variable has enabled property %", A);
4886 Error_Msg_N ("\\corresponding formal has mode IN", A);
4891 -- A formal parameter of a specific tagged type whose related
4892 -- subprogram is subject to pragma Extensions_Visible with value
4893 -- "False" cannot act as an actual in a subprogram with value
4894 -- "True" (SPARK RM 6.1.7(3)).
4896 if Is_EVF_Expression (A)
4897 and then Extensions_Visible_Status (Nam) =
4898 Extensions_Visible_True
4901 ("formal parameter cannot act as actual parameter when "
4902 & "Extensions_Visible is False", A);
4904 ("\subprogram & has Extensions_Visible True", A, Nam);
4907 -- The actual parameter of a Ghost subprogram whose formal is of
4908 -- mode IN OUT or OUT must be a Ghost variable (SPARK RM 6.9(12)).
4910 if Comes_From_Source (Nam)
4911 and then Is_Ghost_Entity (Nam)
4912 and then Ekind_In (F, E_In_Out_Parameter, E_Out_Parameter)
4913 and then Is_Entity_Name (A)
4914 and then Present (Entity (A))
4915 and then not Is_Ghost_Entity (Entity (A))
4918 ("non-ghost variable & cannot appear as actual in call to "
4919 & "ghost procedure", A, Entity (A));
4921 if Ekind (F) = E_In_Out_Parameter then
4922 Error_Msg_N ("\corresponding formal has mode `IN OUT`", A);
4924 Error_Msg_N ("\corresponding formal has mode OUT", A);
4930 -- Case where actual is not present
4938 if Present (Real_Subp) then
4939 Next_Formal (Real_F);
4942 end Resolve_Actuals;
4944 -----------------------
4945 -- Resolve_Allocator --
4946 -----------------------
4948 procedure Resolve_Allocator (N : Node_Id; Typ : Entity_Id) is
4949 Desig_T : constant Entity_Id := Designated_Type (Typ);
4950 E : constant Node_Id := Expression (N);
4952 Discrim : Entity_Id;
4955 Assoc : Node_Id := Empty;
4958 procedure Check_Allocator_Discrim_Accessibility
4959 (Disc_Exp : Node_Id;
4960 Alloc_Typ : Entity_Id);
4961 -- Check that accessibility level associated with an access discriminant
4962 -- initialized in an allocator by the expression Disc_Exp is not deeper
4963 -- than the level of the allocator type Alloc_Typ. An error message is
4964 -- issued if this condition is violated. Specialized checks are done for
4965 -- the cases of a constraint expression which is an access attribute or
4966 -- an access discriminant.
4968 function In_Dispatching_Context return Boolean;
4969 -- If the allocator is an actual in a call, it is allowed to be class-
4970 -- wide when the context is not because it is a controlling actual.
4972 -------------------------------------------
4973 -- Check_Allocator_Discrim_Accessibility --
4974 -------------------------------------------
4976 procedure Check_Allocator_Discrim_Accessibility
4977 (Disc_Exp : Node_Id;
4978 Alloc_Typ : Entity_Id)
4981 if Type_Access_Level (Etype (Disc_Exp)) >
4982 Deepest_Type_Access_Level (Alloc_Typ)
4985 ("operand type has deeper level than allocator type", Disc_Exp);
4987 -- When the expression is an Access attribute the level of the prefix
4988 -- object must not be deeper than that of the allocator's type.
4990 elsif Nkind (Disc_Exp) = N_Attribute_Reference
4991 and then Get_Attribute_Id (Attribute_Name (Disc_Exp)) =
4993 and then Object_Access_Level (Prefix (Disc_Exp)) >
4994 Deepest_Type_Access_Level (Alloc_Typ)
4997 ("prefix of attribute has deeper level than allocator type",
5000 -- When the expression is an access discriminant the check is against
5001 -- the level of the prefix object.
5003 elsif Ekind (Etype (Disc_Exp)) = E_Anonymous_Access_Type
5004 and then Nkind (Disc_Exp) = N_Selected_Component
5005 and then Object_Access_Level (Prefix (Disc_Exp)) >
5006 Deepest_Type_Access_Level (Alloc_Typ)
5009 ("access discriminant has deeper level than allocator type",
5012 -- All other cases are legal
5017 end Check_Allocator_Discrim_Accessibility;
5019 ----------------------------
5020 -- In_Dispatching_Context --
5021 ----------------------------
5023 function In_Dispatching_Context return Boolean is
5024 Par : constant Node_Id := Parent (N);
5027 return Nkind (Par) in N_Subprogram_Call
5028 and then Is_Entity_Name (Name (Par))
5029 and then Is_Dispatching_Operation (Entity (Name (Par)));
5030 end In_Dispatching_Context;
5032 -- Start of processing for Resolve_Allocator
5035 -- Replace general access with specific type
5037 if Ekind (Etype (N)) = E_Allocator_Type then
5038 Set_Etype (N, Base_Type (Typ));
5041 if Is_Abstract_Type (Typ) then
5042 Error_Msg_N ("type of allocator cannot be abstract", N);
5045 -- For qualified expression, resolve the expression using the given
5046 -- subtype (nothing to do for type mark, subtype indication)
5048 if Nkind (E) = N_Qualified_Expression then
5049 if Is_Class_Wide_Type (Etype (E))
5050 and then not Is_Class_Wide_Type (Desig_T)
5051 and then not In_Dispatching_Context
5054 ("class-wide allocator not allowed for this access type", N);
5057 Resolve (Expression (E), Etype (E));
5058 Check_Non_Static_Context (Expression (E));
5059 Check_Unset_Reference (Expression (E));
5061 -- Allocators generated by the build-in-place expansion mechanism
5062 -- are explicitly marked as coming from source but do not need to be
5063 -- checked for limited initialization. To exclude this case, ensure
5064 -- that the parent of the allocator is a source node.
5065 -- The return statement constructed for an Expression_Function does
5066 -- not come from source but requires a limited check.
5068 if Is_Limited_Type (Etype (E))
5069 and then Comes_From_Source (N)
5071 (Comes_From_Source (Parent (N))
5073 (Ekind (Current_Scope) = E_Function
5074 and then Nkind (Original_Node (Unit_Declaration_Node
5075 (Current_Scope))) = N_Expression_Function))
5076 and then not In_Instance_Body
5078 if not OK_For_Limited_Init (Etype (E), Expression (E)) then
5079 if Nkind (Parent (N)) = N_Assignment_Statement then
5081 ("illegal expression for initialized allocator of a "
5082 & "limited type (RM 7.5 (2.7/2))", N);
5085 ("initialization not allowed for limited types", N);
5088 Explain_Limited_Type (Etype (E), N);
5092 -- A qualified expression requires an exact match of the type. Class-
5093 -- wide matching is not allowed.
5095 if (Is_Class_Wide_Type (Etype (Expression (E)))
5096 or else Is_Class_Wide_Type (Etype (E)))
5097 and then Base_Type (Etype (Expression (E))) /= Base_Type (Etype (E))
5099 Wrong_Type (Expression (E), Etype (E));
5102 -- Calls to build-in-place functions are not currently supported in
5103 -- allocators for access types associated with a simple storage pool.
5104 -- Supporting such allocators may require passing additional implicit
5105 -- parameters to build-in-place functions (or a significant revision
5106 -- of the current b-i-p implementation to unify the handling for
5107 -- multiple kinds of storage pools). ???
5109 if Is_Limited_View (Desig_T)
5110 and then Nkind (Expression (E)) = N_Function_Call
5113 Pool : constant Entity_Id :=
5114 Associated_Storage_Pool (Root_Type (Typ));
5118 Present (Get_Rep_Pragma
5119 (Etype (Pool), Name_Simple_Storage_Pool_Type))
5122 ("limited function calls not yet supported in simple "
5123 & "storage pool allocators", Expression (E));
5128 -- A special accessibility check is needed for allocators that
5129 -- constrain access discriminants. The level of the type of the
5130 -- expression used to constrain an access discriminant cannot be
5131 -- deeper than the type of the allocator (in contrast to access
5132 -- parameters, where the level of the actual can be arbitrary).
5134 -- We can't use Valid_Conversion to perform this check because in
5135 -- general the type of the allocator is unrelated to the type of
5136 -- the access discriminant.
5138 if Ekind (Typ) /= E_Anonymous_Access_Type
5139 or else Is_Local_Anonymous_Access (Typ)
5141 Subtyp := Entity (Subtype_Mark (E));
5143 Aggr := Original_Node (Expression (E));
5145 if Has_Discriminants (Subtyp)
5146 and then Nkind_In (Aggr, N_Aggregate, N_Extension_Aggregate)
5148 Discrim := First_Discriminant (Base_Type (Subtyp));
5150 -- Get the first component expression of the aggregate
5152 if Present (Expressions (Aggr)) then
5153 Disc_Exp := First (Expressions (Aggr));
5155 elsif Present (Component_Associations (Aggr)) then
5156 Assoc := First (Component_Associations (Aggr));
5158 if Present (Assoc) then
5159 Disc_Exp := Expression (Assoc);
5168 while Present (Discrim) and then Present (Disc_Exp) loop
5169 if Ekind (Etype (Discrim)) = E_Anonymous_Access_Type then
5170 Check_Allocator_Discrim_Accessibility (Disc_Exp, Typ);
5173 Next_Discriminant (Discrim);
5175 if Present (Discrim) then
5176 if Present (Assoc) then
5178 Disc_Exp := Expression (Assoc);
5180 elsif Present (Next (Disc_Exp)) then
5184 Assoc := First (Component_Associations (Aggr));
5186 if Present (Assoc) then
5187 Disc_Exp := Expression (Assoc);
5197 -- For a subtype mark or subtype indication, freeze the subtype
5200 Freeze_Expression (E);
5202 if Is_Access_Constant (Typ) and then not No_Initialization (N) then
5204 ("initialization required for access-to-constant allocator", N);
5207 -- A special accessibility check is needed for allocators that
5208 -- constrain access discriminants. The level of the type of the
5209 -- expression used to constrain an access discriminant cannot be
5210 -- deeper than the type of the allocator (in contrast to access
5211 -- parameters, where the level of the actual can be arbitrary).
5212 -- We can't use Valid_Conversion to perform this check because
5213 -- in general the type of the allocator is unrelated to the type
5214 -- of the access discriminant.
5216 if Nkind (Original_Node (E)) = N_Subtype_Indication
5217 and then (Ekind (Typ) /= E_Anonymous_Access_Type
5218 or else Is_Local_Anonymous_Access (Typ))
5220 Subtyp := Entity (Subtype_Mark (Original_Node (E)));
5222 if Has_Discriminants (Subtyp) then
5223 Discrim := First_Discriminant (Base_Type (Subtyp));
5224 Constr := First (Constraints (Constraint (Original_Node (E))));
5225 while Present (Discrim) and then Present (Constr) loop
5226 if Ekind (Etype (Discrim)) = E_Anonymous_Access_Type then
5227 if Nkind (Constr) = N_Discriminant_Association then
5228 Disc_Exp := Original_Node (Expression (Constr));
5230 Disc_Exp := Original_Node (Constr);
5233 Check_Allocator_Discrim_Accessibility (Disc_Exp, Typ);
5236 Next_Discriminant (Discrim);
5243 -- Ada 2005 (AI-344): A class-wide allocator requires an accessibility
5244 -- check that the level of the type of the created object is not deeper
5245 -- than the level of the allocator's access type, since extensions can
5246 -- now occur at deeper levels than their ancestor types. This is a
5247 -- static accessibility level check; a run-time check is also needed in
5248 -- the case of an initialized allocator with a class-wide argument (see
5249 -- Expand_Allocator_Expression).
5251 if Ada_Version >= Ada_2005
5252 and then Is_Class_Wide_Type (Desig_T)
5255 Exp_Typ : Entity_Id;
5258 if Nkind (E) = N_Qualified_Expression then
5259 Exp_Typ := Etype (E);
5260 elsif Nkind (E) = N_Subtype_Indication then
5261 Exp_Typ := Entity (Subtype_Mark (Original_Node (E)));
5263 Exp_Typ := Entity (E);
5266 if Type_Access_Level (Exp_Typ) >
5267 Deepest_Type_Access_Level (Typ)
5269 if In_Instance_Body then
5270 Error_Msg_Warn := SPARK_Mode /= On;
5272 ("type in allocator has deeper level than designated "
5273 & "class-wide type<<", E);
5274 Error_Msg_N ("\Program_Error [<<", E);
5277 Make_Raise_Program_Error (Sloc (N),
5278 Reason => PE_Accessibility_Check_Failed));
5281 -- Do not apply Ada 2005 accessibility checks on a class-wide
5282 -- allocator if the type given in the allocator is a formal
5283 -- type. A run-time check will be performed in the instance.
5285 elsif not Is_Generic_Type (Exp_Typ) then
5287 ("type in allocator has deeper level than designated "
5288 & "class-wide type", E);
5294 -- Check for allocation from an empty storage pool. But do not complain
5295 -- if it's a return statement for a build-in-place function, because the
5296 -- allocator is there just in case the caller uses an allocator. If the
5297 -- caller does use an allocator, it will be caught at the call site.
5299 if No_Pool_Assigned (Typ)
5300 and then not Alloc_For_BIP_Return (N)
5302 Error_Msg_N ("allocation from empty storage pool!", N);
5304 -- If the context is an unchecked conversion, as may happen within an
5305 -- inlined subprogram, the allocator is being resolved with its own
5306 -- anonymous type. In that case, if the target type has a specific
5307 -- storage pool, it must be inherited explicitly by the allocator type.
5309 elsif Nkind (Parent (N)) = N_Unchecked_Type_Conversion
5310 and then No (Associated_Storage_Pool (Typ))
5312 Set_Associated_Storage_Pool
5313 (Typ, Associated_Storage_Pool (Etype (Parent (N))));
5316 if Ekind (Etype (N)) = E_Anonymous_Access_Type then
5317 Check_Restriction (No_Anonymous_Allocators, N);
5320 -- Check that an allocator with task parts isn't for a nested access
5321 -- type when restriction No_Task_Hierarchy applies.
5323 if not Is_Library_Level_Entity (Base_Type (Typ))
5324 and then Has_Task (Base_Type (Desig_T))
5326 Check_Restriction (No_Task_Hierarchy, N);
5329 -- An illegal allocator may be rewritten as a raise Program_Error
5332 if Nkind (N) = N_Allocator then
5334 -- Avoid coextension processing for an allocator that is the
5335 -- expansion of a build-in-place function call.
5337 if Nkind (Original_Node (N)) = N_Allocator
5338 and then Nkind (Expression (Original_Node (N))) =
5339 N_Qualified_Expression
5340 and then Nkind (Expression (Expression (Original_Node (N)))) =
5342 and then Is_Expanded_Build_In_Place_Call
5343 (Expression (Expression (Original_Node (N))))
5345 null; -- b-i-p function call case
5348 -- An anonymous access discriminant is the definition of a
5351 if Ekind (Typ) = E_Anonymous_Access_Type
5352 and then Nkind (Associated_Node_For_Itype (Typ)) =
5353 N_Discriminant_Specification
5356 Discr : constant Entity_Id :=
5357 Defining_Identifier (Associated_Node_For_Itype (Typ));
5360 Check_Restriction (No_Coextensions, N);
5362 -- Ada 2012 AI05-0052: If the designated type of the
5363 -- allocator is limited, then the allocator shall not
5364 -- be used to define the value of an access discriminant
5365 -- unless the discriminated type is immutably limited.
5367 if Ada_Version >= Ada_2012
5368 and then Is_Limited_Type (Desig_T)
5369 and then not Is_Limited_View (Scope (Discr))
5372 ("only immutably limited types can have anonymous "
5373 & "access discriminants designating a limited type",
5378 -- Avoid marking an allocator as a dynamic coextension if it is
5379 -- within a static construct.
5381 if not Is_Static_Coextension (N) then
5382 Set_Is_Dynamic_Coextension (N);
5384 -- Finalization and deallocation of coextensions utilizes an
5385 -- approximate implementation which does not directly adhere
5386 -- to the semantic rules. Warn on potential issues involving
5389 if Is_Controlled (Desig_T) then
5391 ("??coextension will not be finalized when its "
5392 & "associated owner is deallocated or finalized", N);
5395 ("??coextension will not be deallocated when its "
5396 & "associated owner is deallocated", N);
5400 -- Cleanup for potential static coextensions
5403 Set_Is_Dynamic_Coextension (N, False);
5404 Set_Is_Static_Coextension (N, False);
5406 -- Anonymous access-to-controlled objects are not finalized on
5407 -- time because this involves run-time ownership and currently
5408 -- this property is not available. In rare cases the object may
5409 -- not be finalized at all. Warn on potential issues involving
5410 -- anonymous access-to-controlled objects.
5412 if Ekind (Typ) = E_Anonymous_Access_Type
5413 and then Is_Controlled_Active (Desig_T)
5416 ("??object designated by anonymous access object might "
5417 & "not be finalized until its enclosing library unit "
5418 & "goes out of scope", N);
5419 Error_Msg_N ("\use named access type instead", N);
5425 -- Report a simple error: if the designated object is a local task,
5426 -- its body has not been seen yet, and its activation will fail an
5427 -- elaboration check.
5429 if Is_Task_Type (Desig_T)
5430 and then Scope (Base_Type (Desig_T)) = Current_Scope
5431 and then Is_Compilation_Unit (Current_Scope)
5432 and then Ekind (Current_Scope) = E_Package
5433 and then not In_Package_Body (Current_Scope)
5435 Error_Msg_Warn := SPARK_Mode /= On;
5436 Error_Msg_N ("cannot activate task before body seen<<", N);
5437 Error_Msg_N ("\Program_Error [<<", N);
5440 -- Ada 2012 (AI05-0111-3): Detect an attempt to allocate a task or a
5441 -- type with a task component on a subpool. This action must raise
5442 -- Program_Error at runtime.
5444 if Ada_Version >= Ada_2012
5445 and then Nkind (N) = N_Allocator
5446 and then Present (Subpool_Handle_Name (N))
5447 and then Has_Task (Desig_T)
5449 Error_Msg_Warn := SPARK_Mode /= On;
5450 Error_Msg_N ("cannot allocate task on subpool<<", N);
5451 Error_Msg_N ("\Program_Error [<<", N);
5454 Make_Raise_Program_Error (Sloc (N),
5455 Reason => PE_Explicit_Raise));
5458 end Resolve_Allocator;
5460 ---------------------------
5461 -- Resolve_Arithmetic_Op --
5462 ---------------------------
5464 -- Used for resolving all arithmetic operators except exponentiation
5466 procedure Resolve_Arithmetic_Op (N : Node_Id; Typ : Entity_Id) is
5467 L : constant Node_Id := Left_Opnd (N);
5468 R : constant Node_Id := Right_Opnd (N);
5469 TL : constant Entity_Id := Base_Type (Etype (L));
5470 TR : constant Entity_Id := Base_Type (Etype (R));
5474 B_Typ : constant Entity_Id := Base_Type (Typ);
5475 -- We do the resolution using the base type, because intermediate values
5476 -- in expressions always are of the base type, not a subtype of it.
5478 function Expected_Type_Is_Any_Real (N : Node_Id) return Boolean;
5479 -- Returns True if N is in a context that expects "any real type"
5481 function Is_Integer_Or_Universal (N : Node_Id) return Boolean;
5482 -- Return True iff given type is Integer or universal real/integer
5484 procedure Set_Mixed_Mode_Operand (N : Node_Id; T : Entity_Id);
5485 -- Choose type of integer literal in fixed-point operation to conform
5486 -- to available fixed-point type. T is the type of the other operand,
5487 -- which is needed to determine the expected type of N.
5489 procedure Set_Operand_Type (N : Node_Id);
5490 -- Set operand type to T if universal
5492 -------------------------------
5493 -- Expected_Type_Is_Any_Real --
5494 -------------------------------
5496 function Expected_Type_Is_Any_Real (N : Node_Id) return Boolean is
5498 -- N is the expression after "delta" in a fixed_point_definition;
5501 return Nkind_In (Parent (N), N_Ordinary_Fixed_Point_Definition,
5502 N_Decimal_Fixed_Point_Definition,
5504 -- N is one of the bounds in a real_range_specification;
5507 N_Real_Range_Specification,
5509 -- N is the expression of a delta_constraint;
5512 N_Delta_Constraint);
5513 end Expected_Type_Is_Any_Real;
5515 -----------------------------
5516 -- Is_Integer_Or_Universal --
5517 -----------------------------
5519 function Is_Integer_Or_Universal (N : Node_Id) return Boolean is
5521 Index : Interp_Index;
5525 if not Is_Overloaded (N) then
5527 return Base_Type (T) = Base_Type (Standard_Integer)
5528 or else T = Universal_Integer
5529 or else T = Universal_Real;
5531 Get_First_Interp (N, Index, It);
5532 while Present (It.Typ) loop
5533 if Base_Type (It.Typ) = Base_Type (Standard_Integer)
5534 or else It.Typ = Universal_Integer
5535 or else It.Typ = Universal_Real
5540 Get_Next_Interp (Index, It);
5545 end Is_Integer_Or_Universal;
5547 ----------------------------
5548 -- Set_Mixed_Mode_Operand --
5549 ----------------------------
5551 procedure Set_Mixed_Mode_Operand (N : Node_Id; T : Entity_Id) is
5552 Index : Interp_Index;
5556 if Universal_Interpretation (N) = Universal_Integer then
5558 -- A universal integer literal is resolved as standard integer
5559 -- except in the case of a fixed-point result, where we leave it
5560 -- as universal (to be handled by Exp_Fixd later on)
5562 if Is_Fixed_Point_Type (T) then
5563 Resolve (N, Universal_Integer);
5565 Resolve (N, Standard_Integer);
5568 elsif Universal_Interpretation (N) = Universal_Real
5569 and then (T = Base_Type (Standard_Integer)
5570 or else T = Universal_Integer
5571 or else T = Universal_Real)
5573 -- A universal real can appear in a fixed-type context. We resolve
5574 -- the literal with that context, even though this might raise an
5575 -- exception prematurely (the other operand may be zero).
5579 elsif Etype (N) = Base_Type (Standard_Integer)
5580 and then T = Universal_Real
5581 and then Is_Overloaded (N)
5583 -- Integer arg in mixed-mode operation. Resolve with universal
5584 -- type, in case preference rule must be applied.
5586 Resolve (N, Universal_Integer);
5588 elsif Etype (N) = T and then B_Typ /= Universal_Fixed then
5590 -- If the operand is part of a fixed multiplication operation,
5591 -- a conversion will be applied to each operand, so resolve it
5592 -- with its own type.
5594 if Nkind_In (Parent (N), N_Op_Divide, N_Op_Multiply) then
5598 -- Not a mixed-mode operation, resolve with context
5603 elsif Etype (N) = Any_Fixed then
5605 -- N may itself be a mixed-mode operation, so use context type
5609 elsif Is_Fixed_Point_Type (T)
5610 and then B_Typ = Universal_Fixed
5611 and then Is_Overloaded (N)
5613 -- Must be (fixed * fixed) operation, operand must have one
5614 -- compatible interpretation.
5616 Resolve (N, Any_Fixed);
5618 elsif Is_Fixed_Point_Type (B_Typ)
5619 and then (T = Universal_Real or else Is_Fixed_Point_Type (T))
5620 and then Is_Overloaded (N)
5622 -- C * F(X) in a fixed context, where C is a real literal or a
5623 -- fixed-point expression. F must have either a fixed type
5624 -- interpretation or an integer interpretation, but not both.
5626 Get_First_Interp (N, Index, It);
5627 while Present (It.Typ) loop
5628 if Base_Type (It.Typ) = Base_Type (Standard_Integer) then
5629 if Analyzed (N) then
5630 Error_Msg_N ("ambiguous operand in fixed operation", N);
5632 Resolve (N, Standard_Integer);
5635 elsif Is_Fixed_Point_Type (It.Typ) then
5636 if Analyzed (N) then
5637 Error_Msg_N ("ambiguous operand in fixed operation", N);
5639 Resolve (N, It.Typ);
5643 Get_Next_Interp (Index, It);
5646 -- Reanalyze the literal with the fixed type of the context. If
5647 -- context is Universal_Fixed, we are within a conversion, leave
5648 -- the literal as a universal real because there is no usable
5649 -- fixed type, and the target of the conversion plays no role in
5663 if B_Typ = Universal_Fixed
5664 and then Nkind (Op2) = N_Real_Literal
5666 T2 := Universal_Real;
5671 Set_Analyzed (Op2, False);
5675 -- A universal real conditional expression can appear in a fixed-type
5676 -- context and must be resolved with that context to facilitate the
5677 -- code generation in the back end. However, If the context is
5678 -- Universal_fixed (i.e. as an operand of a multiplication/division
5679 -- involving a fixed-point operand) the conditional expression must
5680 -- resolve to a unique visible fixed_point type, normally Duration.
5682 elsif Nkind_In (N, N_Case_Expression, N_If_Expression)
5683 and then Etype (N) = Universal_Real
5684 and then Is_Fixed_Point_Type (B_Typ)
5686 if B_Typ = Universal_Fixed then
5687 Resolve (N, Unique_Fixed_Point_Type (N));
5696 end Set_Mixed_Mode_Operand;
5698 ----------------------
5699 -- Set_Operand_Type --
5700 ----------------------
5702 procedure Set_Operand_Type (N : Node_Id) is
5704 if Etype (N) = Universal_Integer
5705 or else Etype (N) = Universal_Real
5709 end Set_Operand_Type;
5711 -- Start of processing for Resolve_Arithmetic_Op
5714 if Comes_From_Source (N)
5715 and then Ekind (Entity (N)) = E_Function
5716 and then Is_Imported (Entity (N))
5717 and then Is_Intrinsic_Subprogram (Entity (N))
5719 Resolve_Intrinsic_Operator (N, Typ);
5722 -- Special-case for mixed-mode universal expressions or fixed point type
5723 -- operation: each argument is resolved separately. The same treatment
5724 -- is required if one of the operands of a fixed point operation is
5725 -- universal real, since in this case we don't do a conversion to a
5726 -- specific fixed-point type (instead the expander handles the case).
5728 -- Set the type of the node to its universal interpretation because
5729 -- legality checks on an exponentiation operand need the context.
5731 elsif (B_Typ = Universal_Integer or else B_Typ = Universal_Real)
5732 and then Present (Universal_Interpretation (L))
5733 and then Present (Universal_Interpretation (R))
5735 Set_Etype (N, B_Typ);
5736 Resolve (L, Universal_Interpretation (L));
5737 Resolve (R, Universal_Interpretation (R));
5739 elsif (B_Typ = Universal_Real
5740 or else Etype (N) = Universal_Fixed
5741 or else (Etype (N) = Any_Fixed
5742 and then Is_Fixed_Point_Type (B_Typ))
5743 or else (Is_Fixed_Point_Type (B_Typ)
5744 and then (Is_Integer_Or_Universal (L)
5746 Is_Integer_Or_Universal (R))))
5747 and then Nkind_In (N, N_Op_Multiply, N_Op_Divide)
5749 if TL = Universal_Integer or else TR = Universal_Integer then
5750 Check_For_Visible_Operator (N, B_Typ);
5753 -- If context is a fixed type and one operand is integer, the other
5754 -- is resolved with the type of the context.
5756 if Is_Fixed_Point_Type (B_Typ)
5757 and then (Base_Type (TL) = Base_Type (Standard_Integer)
5758 or else TL = Universal_Integer)
5763 elsif Is_Fixed_Point_Type (B_Typ)
5764 and then (Base_Type (TR) = Base_Type (Standard_Integer)
5765 or else TR = Universal_Integer)
5770 -- If both operands are universal and the context is a floating
5771 -- point type, the operands are resolved to the type of the context.
5773 elsif Is_Floating_Point_Type (B_Typ) then
5778 Set_Mixed_Mode_Operand (L, TR);
5779 Set_Mixed_Mode_Operand (R, TL);
5782 -- Check the rule in RM05-4.5.5(19.1/2) disallowing universal_fixed
5783 -- multiplying operators from being used when the expected type is
5784 -- also universal_fixed. Note that B_Typ will be Universal_Fixed in
5785 -- some cases where the expected type is actually Any_Real;
5786 -- Expected_Type_Is_Any_Real takes care of that case.
5788 if Etype (N) = Universal_Fixed
5789 or else Etype (N) = Any_Fixed
5791 if B_Typ = Universal_Fixed
5792 and then not Expected_Type_Is_Any_Real (N)
5793 and then not Nkind_In (Parent (N), N_Type_Conversion,
5794 N_Unchecked_Type_Conversion)
5796 Error_Msg_N ("type cannot be determined from context!", N);
5797 Error_Msg_N ("\explicit conversion to result type required", N);
5799 Set_Etype (L, Any_Type);
5800 Set_Etype (R, Any_Type);
5803 if Ada_Version = Ada_83
5804 and then Etype (N) = Universal_Fixed
5806 Nkind_In (Parent (N), N_Type_Conversion,
5807 N_Unchecked_Type_Conversion)
5810 ("(Ada 83) fixed-point operation needs explicit "
5814 -- The expected type is "any real type" in contexts like
5816 -- type T is delta <universal_fixed-expression> ...
5818 -- in which case we need to set the type to Universal_Real
5819 -- so that static expression evaluation will work properly.
5821 if Expected_Type_Is_Any_Real (N) then
5822 Set_Etype (N, Universal_Real);
5824 Set_Etype (N, B_Typ);
5828 elsif Is_Fixed_Point_Type (B_Typ)
5829 and then (Is_Integer_Or_Universal (L)
5830 or else Nkind (L) = N_Real_Literal
5831 or else Nkind (R) = N_Real_Literal
5832 or else Is_Integer_Or_Universal (R))
5834 Set_Etype (N, B_Typ);
5836 elsif Etype (N) = Any_Fixed then
5838 -- If no previous errors, this is only possible if one operand is
5839 -- overloaded and the context is universal. Resolve as such.
5841 Set_Etype (N, B_Typ);
5845 if (TL = Universal_Integer or else TL = Universal_Real)
5847 (TR = Universal_Integer or else TR = Universal_Real)
5849 Check_For_Visible_Operator (N, B_Typ);
5852 -- If the context is Universal_Fixed and the operands are also
5853 -- universal fixed, this is an error, unless there is only one
5854 -- applicable fixed_point type (usually Duration).
5856 if B_Typ = Universal_Fixed and then Etype (L) = Universal_Fixed then
5857 T := Unique_Fixed_Point_Type (N);
5859 if T = Any_Type then
5872 -- If one of the arguments was resolved to a non-universal type.
5873 -- label the result of the operation itself with the same type.
5874 -- Do the same for the universal argument, if any.
5876 T := Intersect_Types (L, R);
5877 Set_Etype (N, Base_Type (T));
5878 Set_Operand_Type (L);
5879 Set_Operand_Type (R);
5882 Generate_Operator_Reference (N, Typ);
5883 Analyze_Dimension (N);
5884 Eval_Arithmetic_Op (N);
5886 -- In SPARK, a multiplication or division with operands of fixed point
5887 -- types must be qualified or explicitly converted to identify the
5890 if (Is_Fixed_Point_Type (Etype (L))
5891 or else Is_Fixed_Point_Type (Etype (R)))
5892 and then Nkind_In (N, N_Op_Multiply, N_Op_Divide)
5894 not Nkind_In (Parent (N), N_Qualified_Expression, N_Type_Conversion)
5896 Check_SPARK_05_Restriction
5897 ("operation should be qualified or explicitly converted", N);
5900 -- Set overflow and division checking bit
5902 if Nkind (N) in N_Op then
5903 if not Overflow_Checks_Suppressed (Etype (N)) then
5904 Enable_Overflow_Check (N);
5907 -- Give warning if explicit division by zero
5909 if Nkind_In (N, N_Op_Divide, N_Op_Rem, N_Op_Mod)
5910 and then not Division_Checks_Suppressed (Etype (N))
5912 Rop := Right_Opnd (N);
5914 if Compile_Time_Known_Value (Rop)
5915 and then ((Is_Integer_Type (Etype (Rop))
5916 and then Expr_Value (Rop) = Uint_0)
5918 (Is_Real_Type (Etype (Rop))
5919 and then Expr_Value_R (Rop) = Ureal_0))
5921 -- Specialize the warning message according to the operation.
5922 -- When SPARK_Mode is On, force a warning instead of an error
5923 -- in that case, as this likely corresponds to deactivated
5924 -- code. The following warnings are for the case
5929 -- For division, we have two cases, for float division
5930 -- of an unconstrained float type, on a machine where
5931 -- Machine_Overflows is false, we don't get an exception
5932 -- at run-time, but rather an infinity or Nan. The Nan
5933 -- case is pretty obscure, so just warn about infinities.
5935 if Is_Floating_Point_Type (Typ)
5936 and then not Is_Constrained (Typ)
5937 and then not Machine_Overflows_On_Target
5940 ("float division by zero, may generate "
5941 & "'+'/'- infinity??", Right_Opnd (N));
5943 -- For all other cases, we get a Constraint_Error
5946 Apply_Compile_Time_Constraint_Error
5947 (N, "division by zero??", CE_Divide_By_Zero,
5948 Loc => Sloc (Right_Opnd (N)),
5949 Warn => SPARK_Mode = On);
5953 Apply_Compile_Time_Constraint_Error
5954 (N, "rem with zero divisor??", CE_Divide_By_Zero,
5955 Loc => Sloc (Right_Opnd (N)),
5956 Warn => SPARK_Mode = On);
5959 Apply_Compile_Time_Constraint_Error
5960 (N, "mod with zero divisor??", CE_Divide_By_Zero,
5961 Loc => Sloc (Right_Opnd (N)),
5962 Warn => SPARK_Mode = On);
5964 -- Division by zero can only happen with division, rem,
5965 -- and mod operations.
5968 raise Program_Error;
5971 -- In GNATprove mode, we enable the division check so that
5972 -- GNATprove will issue a message if it cannot be proved.
5974 if GNATprove_Mode then
5975 Activate_Division_Check (N);
5978 -- Otherwise just set the flag to check at run time
5981 Activate_Division_Check (N);
5985 -- If Restriction No_Implicit_Conditionals is active, then it is
5986 -- violated if either operand can be negative for mod, or for rem
5987 -- if both operands can be negative.
5989 if Restriction_Check_Required (No_Implicit_Conditionals)
5990 and then Nkind_In (N, N_Op_Rem, N_Op_Mod)
5999 -- Set if corresponding operand might be negative
6003 (Left_Opnd (N), OK, Lo, Hi, Assume_Valid => True);
6004 LNeg := (not OK) or else Lo < 0;
6007 (Right_Opnd (N), OK, Lo, Hi, Assume_Valid => True);
6008 RNeg := (not OK) or else Lo < 0;
6010 -- Check if we will be generating conditionals. There are two
6011 -- cases where that can happen, first for REM, the only case
6012 -- is largest negative integer mod -1, where the division can
6013 -- overflow, but we still have to give the right result. The
6014 -- front end generates a test for this annoying case. Here we
6015 -- just test if both operands can be negative (that's what the
6016 -- expander does, so we match its logic here).
6018 -- The second case is mod where either operand can be negative.
6019 -- In this case, the back end has to generate additional tests.
6021 if (Nkind (N) = N_Op_Rem and then (LNeg and RNeg))
6023 (Nkind (N) = N_Op_Mod and then (LNeg or RNeg))
6025 Check_Restriction (No_Implicit_Conditionals, N);
6031 Check_Unset_Reference (L);
6032 Check_Unset_Reference (R);
6033 end Resolve_Arithmetic_Op;
6039 procedure Resolve_Call (N : Node_Id; Typ : Entity_Id) is
6040 function Same_Or_Aliased_Subprograms
6042 E : Entity_Id) return Boolean;
6043 -- Returns True if the subprogram entity S is the same as E or else
6044 -- S is an alias of E.
6046 ---------------------------------
6047 -- Same_Or_Aliased_Subprograms --
6048 ---------------------------------
6050 function Same_Or_Aliased_Subprograms
6052 E : Entity_Id) return Boolean
6054 Subp_Alias : constant Entity_Id := Alias (S);
6056 return S = E or else (Present (Subp_Alias) and then Subp_Alias = E);
6057 end Same_Or_Aliased_Subprograms;
6061 Loc : constant Source_Ptr := Sloc (N);
6062 Subp : constant Node_Id := Name (N);
6063 Body_Id : Entity_Id;
6073 -- Start of processing for Resolve_Call
6076 -- Preserve relevant elaboration-related attributes of the context which
6077 -- are no longer available or very expensive to recompute once analysis,
6078 -- resolution, and expansion are over.
6080 Mark_Elaboration_Attributes
6086 -- The context imposes a unique interpretation with type Typ on a
6087 -- procedure or function call. Find the entity of the subprogram that
6088 -- yields the expected type, and propagate the corresponding formal
6089 -- constraints on the actuals. The caller has established that an
6090 -- interpretation exists, and emitted an error if not unique.
6092 -- First deal with the case of a call to an access-to-subprogram,
6093 -- dereference made explicit in Analyze_Call.
6095 if Ekind (Etype (Subp)) = E_Subprogram_Type then
6096 if not Is_Overloaded (Subp) then
6097 Nam := Etype (Subp);
6100 -- Find the interpretation whose type (a subprogram type) has a
6101 -- return type that is compatible with the context. Analysis of
6102 -- the node has established that one exists.
6106 Get_First_Interp (Subp, I, It);
6107 while Present (It.Typ) loop
6108 if Covers (Typ, Etype (It.Typ)) then
6113 Get_Next_Interp (I, It);
6117 raise Program_Error;
6121 -- If the prefix is not an entity, then resolve it
6123 if not Is_Entity_Name (Subp) then
6124 Resolve (Subp, Nam);
6127 -- For an indirect call, we always invalidate checks, since we do not
6128 -- know whether the subprogram is local or global. Yes we could do
6129 -- better here, e.g. by knowing that there are no local subprograms,
6130 -- but it does not seem worth the effort. Similarly, we kill all
6131 -- knowledge of current constant values.
6133 Kill_Current_Values;
6135 -- If this is a procedure call which is really an entry call, do
6136 -- the conversion of the procedure call to an entry call. Protected
6137 -- operations use the same circuitry because the name in the call
6138 -- can be an arbitrary expression with special resolution rules.
6140 elsif Nkind_In (Subp, N_Selected_Component, N_Indexed_Component)
6141 or else (Is_Entity_Name (Subp)
6142 and then Ekind_In (Entity (Subp), E_Entry, E_Entry_Family))
6144 Resolve_Entry_Call (N, Typ);
6146 if Legacy_Elaboration_Checks then
6147 Check_Elab_Call (N);
6150 -- Annotate the tree by creating a call marker in case the original
6151 -- call is transformed by expansion. The call marker is automatically
6152 -- saved for later examination by the ABE Processing phase.
6154 Build_Call_Marker (N);
6156 -- Kill checks and constant values, as above for indirect case
6157 -- Who knows what happens when another task is activated?
6159 Kill_Current_Values;
6162 -- Normal subprogram call with name established in Resolve
6164 elsif not (Is_Type (Entity (Subp))) then
6165 Nam := Entity (Subp);
6166 Set_Entity_With_Checks (Subp, Nam);
6168 -- Otherwise we must have the case of an overloaded call
6171 pragma Assert (Is_Overloaded (Subp));
6173 -- Initialize Nam to prevent warning (we know it will be assigned
6174 -- in the loop below, but the compiler does not know that).
6178 Get_First_Interp (Subp, I, It);
6179 while Present (It.Typ) loop
6180 if Covers (Typ, It.Typ) then
6182 Set_Entity_With_Checks (Subp, Nam);
6186 Get_Next_Interp (I, It);
6190 if Is_Access_Subprogram_Type (Base_Type (Etype (Nam)))
6191 and then not Is_Access_Subprogram_Type (Base_Type (Typ))
6192 and then Nkind (Subp) /= N_Explicit_Dereference
6193 and then Present (Parameter_Associations (N))
6195 -- The prefix is a parameterless function call that returns an access
6196 -- to subprogram. If parameters are present in the current call, add
6197 -- add an explicit dereference. We use the base type here because
6198 -- within an instance these may be subtypes.
6200 -- The dereference is added either in Analyze_Call or here. Should
6201 -- be consolidated ???
6203 Set_Is_Overloaded (Subp, False);
6204 Set_Etype (Subp, Etype (Nam));
6205 Insert_Explicit_Dereference (Subp);
6206 Nam := Designated_Type (Etype (Nam));
6207 Resolve (Subp, Nam);
6210 -- Check that a call to Current_Task does not occur in an entry body
6212 if Is_RTE (Nam, RE_Current_Task) then
6221 -- Exclude calls that occur within the default of a formal
6222 -- parameter of the entry, since those are evaluated outside
6225 exit when No (P) or else Nkind (P) = N_Parameter_Specification;
6227 if Nkind (P) = N_Entry_Body
6228 or else (Nkind (P) = N_Subprogram_Body
6229 and then Is_Entry_Barrier_Function (P))
6232 Error_Msg_Warn := SPARK_Mode /= On;
6234 ("& should not be used in entry body (RM C.7(17))<<",
6236 Error_Msg_NE ("\Program_Error [<<", N, Nam);
6238 Make_Raise_Program_Error (Loc,
6239 Reason => PE_Current_Task_In_Entry_Body));
6240 Set_Etype (N, Rtype);
6247 -- Check that a procedure call does not occur in the context of the
6248 -- entry call statement of a conditional or timed entry call. Note that
6249 -- the case of a call to a subprogram renaming of an entry will also be
6250 -- rejected. The test for N not being an N_Entry_Call_Statement is
6251 -- defensive, covering the possibility that the processing of entry
6252 -- calls might reach this point due to later modifications of the code
6255 if Nkind (Parent (N)) = N_Entry_Call_Alternative
6256 and then Nkind (N) /= N_Entry_Call_Statement
6257 and then Entry_Call_Statement (Parent (N)) = N
6259 if Ada_Version < Ada_2005 then
6260 Error_Msg_N ("entry call required in select statement", N);
6262 -- Ada 2005 (AI-345): If a procedure_call_statement is used
6263 -- for a procedure_or_entry_call, the procedure_name or
6264 -- procedure_prefix of the procedure_call_statement shall denote
6265 -- an entry renamed by a procedure, or (a view of) a primitive
6266 -- subprogram of a limited interface whose first parameter is
6267 -- a controlling parameter.
6269 elsif Nkind (N) = N_Procedure_Call_Statement
6270 and then not Is_Renamed_Entry (Nam)
6271 and then not Is_Controlling_Limited_Procedure (Nam)
6274 ("entry call or dispatching primitive of interface required", N);
6278 -- If the SPARK_05 restriction is active, we are not allowed
6279 -- to have a call to a subprogram before we see its completion.
6281 if not Has_Completion (Nam)
6282 and then Restriction_Check_Required (SPARK_05)
6284 -- Don't flag strange internal calls
6286 and then Comes_From_Source (N)
6287 and then Comes_From_Source (Nam)
6289 -- Only flag calls in extended main source
6291 and then In_Extended_Main_Source_Unit (Nam)
6292 and then In_Extended_Main_Source_Unit (N)
6294 -- Exclude enumeration literals from this processing
6296 and then Ekind (Nam) /= E_Enumeration_Literal
6298 Check_SPARK_05_Restriction
6299 ("call to subprogram cannot appear before its body", N);
6302 -- Check that this is not a call to a protected procedure or entry from
6303 -- within a protected function.
6305 Check_Internal_Protected_Use (N, Nam);
6307 -- Freeze the subprogram name if not in a spec-expression. Note that
6308 -- we freeze procedure calls as well as function calls. Procedure calls
6309 -- are not frozen according to the rules (RM 13.14(14)) because it is
6310 -- impossible to have a procedure call to a non-frozen procedure in
6311 -- pure Ada, but in the code that we generate in the expander, this
6312 -- rule needs extending because we can generate procedure calls that
6315 -- In Ada 2012, expression functions may be called within pre/post
6316 -- conditions of subsequent functions or expression functions. Such
6317 -- calls do not freeze when they appear within generated bodies,
6318 -- (including the body of another expression function) which would
6319 -- place the freeze node in the wrong scope. An expression function
6320 -- is frozen in the usual fashion, by the appearance of a real body,
6321 -- or at the end of a declarative part. However an implicit call to
6322 -- an expression function may appear when it is part of a default
6323 -- expression in a call to an initialization procedure, and must be
6324 -- frozen now, even if the body is inserted at a later point.
6325 -- Otherwise, the call freezes the expression if expander is active,
6326 -- for example as part of an object declaration.
6328 if Is_Entity_Name (Subp)
6329 and then not In_Spec_Expression
6330 and then not Is_Expression_Function_Or_Completion (Current_Scope)
6332 (not Is_Expression_Function_Or_Completion (Entity (Subp))
6333 or else Expander_Active)
6335 if Is_Expression_Function (Entity (Subp)) then
6337 -- Force freeze of expression function in call
6339 Set_Comes_From_Source (Subp, True);
6340 Set_Must_Not_Freeze (Subp, False);
6343 Freeze_Expression (Subp);
6346 -- For a predefined operator, the type of the result is the type imposed
6347 -- by context, except for a predefined operation on universal fixed.
6348 -- Otherwise the type of the call is the type returned by the subprogram
6351 if Is_Predefined_Op (Nam) then
6352 if Etype (N) /= Universal_Fixed then
6356 -- If the subprogram returns an array type, and the context requires the
6357 -- component type of that array type, the node is really an indexing of
6358 -- the parameterless call. Resolve as such. A pathological case occurs
6359 -- when the type of the component is an access to the array type. In
6360 -- this case the call is truly ambiguous. If the call is to an intrinsic
6361 -- subprogram, it can't be an indexed component. This check is necessary
6362 -- because if it's Unchecked_Conversion, and we have "type T_Ptr is
6363 -- access T;" and "type T is array (...) of T_Ptr;" (i.e. an array of
6364 -- pointers to the same array), the compiler gets confused and does an
6365 -- infinite recursion.
6367 elsif (Needs_No_Actuals (Nam) or else Needs_One_Actual (Nam))
6369 ((Is_Array_Type (Etype (Nam))
6370 and then Covers (Typ, Component_Type (Etype (Nam))))
6372 (Is_Access_Type (Etype (Nam))
6373 and then Is_Array_Type (Designated_Type (Etype (Nam)))
6375 Covers (Typ, Component_Type (Designated_Type (Etype (Nam))))
6376 and then not Is_Intrinsic_Subprogram (Entity (Subp))))
6379 Index_Node : Node_Id;
6381 Ret_Type : constant Entity_Id := Etype (Nam);
6384 -- If this is a parameterless call there is no ambiguity and the
6385 -- call has the type of the function.
6387 if No (First_Actual (N)) then
6388 Set_Etype (N, Etype (Nam));
6390 if Present (First_Formal (Nam)) then
6391 Resolve_Actuals (N, Nam);
6394 -- Annotate the tree by creating a call marker in case the
6395 -- original call is transformed by expansion. The call marker
6396 -- is automatically saved for later examination by the ABE
6397 -- Processing phase.
6399 Build_Call_Marker (N);
6401 elsif Is_Access_Type (Ret_Type)
6403 and then Ret_Type = Component_Type (Designated_Type (Ret_Type))
6406 ("cannot disambiguate function call and indexing", N);
6408 New_Subp := Relocate_Node (Subp);
6410 -- The called entity may be an explicit dereference, in which
6411 -- case there is no entity to set.
6413 if Nkind (New_Subp) /= N_Explicit_Dereference then
6414 Set_Entity (Subp, Nam);
6417 if (Is_Array_Type (Ret_Type)
6418 and then Component_Type (Ret_Type) /= Any_Type)
6420 (Is_Access_Type (Ret_Type)
6422 Component_Type (Designated_Type (Ret_Type)) /= Any_Type)
6424 if Needs_No_Actuals (Nam) then
6426 -- Indexed call to a parameterless function
6429 Make_Indexed_Component (Loc,
6431 Make_Function_Call (Loc, Name => New_Subp),
6432 Expressions => Parameter_Associations (N));
6434 -- An Ada 2005 prefixed call to a primitive operation
6435 -- whose first parameter is the prefix. This prefix was
6436 -- prepended to the parameter list, which is actually a
6437 -- list of indexes. Remove the prefix in order to build
6438 -- the proper indexed component.
6441 Make_Indexed_Component (Loc,
6443 Make_Function_Call (Loc,
6445 Parameter_Associations =>
6447 (Remove_Head (Parameter_Associations (N)))),
6448 Expressions => Parameter_Associations (N));
6451 -- Preserve the parenthesis count of the node
6453 Set_Paren_Count (Index_Node, Paren_Count (N));
6455 -- Since we are correcting a node classification error made
6456 -- by the parser, we call Replace rather than Rewrite.
6458 Replace (N, Index_Node);
6460 Set_Etype (Prefix (N), Ret_Type);
6462 Resolve_Indexed_Component (N, Typ);
6464 if Legacy_Elaboration_Checks then
6465 Check_Elab_Call (Prefix (N));
6468 -- Annotate the tree by creating a call marker in case
6469 -- the original call is transformed by expansion. The call
6470 -- marker is automatically saved for later examination by
6471 -- the ABE Processing phase.
6473 Build_Call_Marker (Prefix (N));
6481 -- If the called function is not declared in the main unit and it
6482 -- returns the limited view of type then use the available view (as
6483 -- is done in Try_Object_Operation) to prevent back-end confusion;
6484 -- for the function entity itself. The call must appear in a context
6485 -- where the nonlimited view is available. If the function entity is
6486 -- in the extended main unit then no action is needed, because the
6487 -- back end handles this case. In either case the type of the call
6488 -- is the nonlimited view.
6490 if From_Limited_With (Etype (Nam))
6491 and then Present (Available_View (Etype (Nam)))
6493 Set_Etype (N, Available_View (Etype (Nam)));
6495 if not In_Extended_Main_Code_Unit (Nam) then
6496 Set_Etype (Nam, Available_View (Etype (Nam)));
6500 Set_Etype (N, Etype (Nam));
6504 -- In the case where the call is to an overloaded subprogram, Analyze
6505 -- calls Normalize_Actuals once per overloaded subprogram. Therefore in
6506 -- such a case Normalize_Actuals needs to be called once more to order
6507 -- the actuals correctly. Otherwise the call will have the ordering
6508 -- given by the last overloaded subprogram whether this is the correct
6509 -- one being called or not.
6511 if Is_Overloaded (Subp) then
6512 Normalize_Actuals (N, Nam, False, Norm_OK);
6513 pragma Assert (Norm_OK);
6516 -- In any case, call is fully resolved now. Reset Overload flag, to
6517 -- prevent subsequent overload resolution if node is analyzed again
6519 Set_Is_Overloaded (Subp, False);
6520 Set_Is_Overloaded (N, False);
6522 -- A Ghost entity must appear in a specific context
6524 if Is_Ghost_Entity (Nam) and then Comes_From_Source (N) then
6525 Check_Ghost_Context (Nam, N);
6528 -- If we are calling the current subprogram from immediately within its
6529 -- body, then that is the case where we can sometimes detect cases of
6530 -- infinite recursion statically. Do not try this in case restriction
6531 -- No_Recursion is in effect anyway, and do it only for source calls.
6533 if Comes_From_Source (N) then
6534 Scop := Current_Scope;
6536 -- Check violation of SPARK_05 restriction which does not permit
6537 -- a subprogram body to contain a call to the subprogram directly.
6539 if Restriction_Check_Required (SPARK_05)
6540 and then Same_Or_Aliased_Subprograms (Nam, Scop)
6542 Check_SPARK_05_Restriction
6543 ("subprogram may not contain direct call to itself", N);
6546 -- Issue warning for possible infinite recursion in the absence
6547 -- of the No_Recursion restriction.
6549 if Same_Or_Aliased_Subprograms (Nam, Scop)
6550 and then not Restriction_Active (No_Recursion)
6551 and then Check_Infinite_Recursion (N)
6553 -- Here we detected and flagged an infinite recursion, so we do
6554 -- not need to test the case below for further warnings. Also we
6555 -- are all done if we now have a raise SE node.
6557 if Nkind (N) = N_Raise_Storage_Error then
6561 -- If call is to immediately containing subprogram, then check for
6562 -- the case of a possible run-time detectable infinite recursion.
6565 Scope_Loop : while Scop /= Standard_Standard loop
6566 if Same_Or_Aliased_Subprograms (Nam, Scop) then
6568 -- Although in general case, recursion is not statically
6569 -- checkable, the case of calling an immediately containing
6570 -- subprogram is easy to catch.
6572 Check_Restriction (No_Recursion, N);
6574 -- If the recursive call is to a parameterless subprogram,
6575 -- then even if we can't statically detect infinite
6576 -- recursion, this is pretty suspicious, and we output a
6577 -- warning. Furthermore, we will try later to detect some
6578 -- cases here at run time by expanding checking code (see
6579 -- Detect_Infinite_Recursion in package Exp_Ch6).
6581 -- If the recursive call is within a handler, do not emit a
6582 -- warning, because this is a common idiom: loop until input
6583 -- is correct, catch illegal input in handler and restart.
6585 if No (First_Formal (Nam))
6586 and then Etype (Nam) = Standard_Void_Type
6587 and then not Error_Posted (N)
6588 and then Nkind (Parent (N)) /= N_Exception_Handler
6590 -- For the case of a procedure call. We give the message
6591 -- only if the call is the first statement in a sequence
6592 -- of statements, or if all previous statements are
6593 -- simple assignments. This is simply a heuristic to
6594 -- decrease false positives, without losing too many good
6595 -- warnings. The idea is that these previous statements
6596 -- may affect global variables the procedure depends on.
6597 -- We also exclude raise statements, that may arise from
6598 -- constraint checks and are probably unrelated to the
6599 -- intended control flow.
6601 if Nkind (N) = N_Procedure_Call_Statement
6602 and then Is_List_Member (N)
6608 while Present (P) loop
6609 if not Nkind_In (P, N_Assignment_Statement,
6610 N_Raise_Constraint_Error)
6620 -- Do not give warning if we are in a conditional context
6623 K : constant Node_Kind := Nkind (Parent (N));
6625 if (K = N_Loop_Statement
6626 and then Present (Iteration_Scheme (Parent (N))))
6627 or else K = N_If_Statement
6628 or else K = N_Elsif_Part
6629 or else K = N_Case_Statement_Alternative
6635 -- Here warning is to be issued
6637 Set_Has_Recursive_Call (Nam);
6638 Error_Msg_Warn := SPARK_Mode /= On;
6639 Error_Msg_N ("possible infinite recursion<<!", N);
6640 Error_Msg_N ("\Storage_Error ]<<!", N);
6646 Scop := Scope (Scop);
6647 end loop Scope_Loop;
6651 -- Check obsolescent reference to Ada.Characters.Handling subprogram
6653 Check_Obsolescent_2005_Entity (Nam, Subp);
6655 -- If subprogram name is a predefined operator, it was given in
6656 -- functional notation. Replace call node with operator node, so
6657 -- that actuals can be resolved appropriately.
6659 if Is_Predefined_Op (Nam) or else Ekind (Nam) = E_Operator then
6660 Make_Call_Into_Operator (N, Typ, Entity (Name (N)));
6663 elsif Present (Alias (Nam))
6664 and then Is_Predefined_Op (Alias (Nam))
6666 Resolve_Actuals (N, Nam);
6667 Make_Call_Into_Operator (N, Typ, Alias (Nam));
6671 -- Create a transient scope if the resulting type requires it
6673 -- There are several notable exceptions:
6675 -- a) In init procs, the transient scope overhead is not needed, and is
6676 -- even incorrect when the call is a nested initialization call for a
6677 -- component whose expansion may generate adjust calls. However, if the
6678 -- call is some other procedure call within an initialization procedure
6679 -- (for example a call to Create_Task in the init_proc of the task
6680 -- run-time record) a transient scope must be created around this call.
6682 -- b) Enumeration literal pseudo-calls need no transient scope
6684 -- c) Intrinsic subprograms (Unchecked_Conversion and source info
6685 -- functions) do not use the secondary stack even though the return
6686 -- type may be unconstrained.
6688 -- d) Calls to a build-in-place function, since such functions may
6689 -- allocate their result directly in a target object, and cases where
6690 -- the result does get allocated in the secondary stack are checked for
6691 -- within the specialized Exp_Ch6 procedures for expanding those
6692 -- build-in-place calls.
6694 -- e) Calls to inlinable expression functions do not use the secondary
6695 -- stack (since the call will be replaced by its returned object).
6697 -- f) If the subprogram is marked Inline_Always, then even if it returns
6698 -- an unconstrained type the call does not require use of the secondary
6699 -- stack. However, inlining will only take place if the body to inline
6700 -- is already present. It may not be available if e.g. the subprogram is
6701 -- declared in a child instance.
6704 and then Has_Pragma_Inline (Nam)
6705 and then Nkind (Unit_Declaration_Node (Nam)) = N_Subprogram_Declaration
6706 and then Present (Body_To_Inline (Unit_Declaration_Node (Nam)))
6710 elsif Ekind (Nam) = E_Enumeration_Literal
6711 or else Is_Build_In_Place_Function (Nam)
6712 or else Is_Intrinsic_Subprogram (Nam)
6713 or else Is_Inlinable_Expression_Function (Nam)
6717 elsif Expander_Active
6718 and then Ekind_In (Nam, E_Function, E_Subprogram_Type)
6719 and then Requires_Transient_Scope (Etype (Nam))
6721 Establish_Transient_Scope (N, Manage_Sec_Stack => True);
6723 -- If the call appears within the bounds of a loop, it will be
6724 -- rewritten and reanalyzed, nothing left to do here.
6726 if Nkind (N) /= N_Function_Call then
6731 -- A protected function cannot be called within the definition of the
6732 -- enclosing protected type, unless it is part of a pre/postcondition
6733 -- on another protected operation. This may appear in the entry wrapper
6734 -- created for an entry with preconditions.
6736 if Is_Protected_Type (Scope (Nam))
6737 and then In_Open_Scopes (Scope (Nam))
6738 and then not Has_Completion (Scope (Nam))
6739 and then not In_Spec_Expression
6740 and then not Is_Entry_Wrapper (Current_Scope)
6743 ("& cannot be called before end of protected definition", N, Nam);
6746 -- Propagate interpretation to actuals, and add default expressions
6749 if Present (First_Formal (Nam)) then
6750 Resolve_Actuals (N, Nam);
6752 -- Overloaded literals are rewritten as function calls, for purpose of
6753 -- resolution. After resolution, we can replace the call with the
6756 elsif Ekind (Nam) = E_Enumeration_Literal then
6757 Copy_Node (Subp, N);
6758 Resolve_Entity_Name (N, Typ);
6760 -- Avoid validation, since it is a static function call
6762 Generate_Reference (Nam, Subp);
6766 -- If the subprogram is not global, then kill all saved values and
6767 -- checks. This is a bit conservative, since in many cases we could do
6768 -- better, but it is not worth the effort. Similarly, we kill constant
6769 -- values. However we do not need to do this for internal entities
6770 -- (unless they are inherited user-defined subprograms), since they
6771 -- are not in the business of molesting local values.
6773 -- If the flag Suppress_Value_Tracking_On_Calls is set, then we also
6774 -- kill all checks and values for calls to global subprograms. This
6775 -- takes care of the case where an access to a local subprogram is
6776 -- taken, and could be passed directly or indirectly and then called
6777 -- from almost any context.
6779 -- Note: we do not do this step till after resolving the actuals. That
6780 -- way we still take advantage of the current value information while
6781 -- scanning the actuals.
6783 -- We suppress killing values if we are processing the nodes associated
6784 -- with N_Freeze_Entity nodes. Otherwise the declaration of a tagged
6785 -- type kills all the values as part of analyzing the code that
6786 -- initializes the dispatch tables.
6788 if Inside_Freezing_Actions = 0
6789 and then (not Is_Library_Level_Entity (Nam)
6790 or else Suppress_Value_Tracking_On_Call
6791 (Nearest_Dynamic_Scope (Current_Scope)))
6792 and then (Comes_From_Source (Nam)
6793 or else (Present (Alias (Nam))
6794 and then Comes_From_Source (Alias (Nam))))
6796 Kill_Current_Values;
6799 -- If we are warning about unread OUT parameters, this is the place to
6800 -- set Last_Assignment for OUT and IN OUT parameters. We have to do this
6801 -- after the above call to Kill_Current_Values (since that call clears
6802 -- the Last_Assignment field of all local variables).
6804 if (Warn_On_Modified_Unread or Warn_On_All_Unread_Out_Parameters)
6805 and then Comes_From_Source (N)
6806 and then In_Extended_Main_Source_Unit (N)
6813 F := First_Formal (Nam);
6814 A := First_Actual (N);
6815 while Present (F) and then Present (A) loop
6816 if Ekind_In (F, E_Out_Parameter, E_In_Out_Parameter)
6817 and then Warn_On_Modified_As_Out_Parameter (F)
6818 and then Is_Entity_Name (A)
6819 and then Present (Entity (A))
6820 and then Comes_From_Source (N)
6821 and then Safe_To_Capture_Value (N, Entity (A))
6823 Set_Last_Assignment (Entity (A), A);
6832 -- If the subprogram is a primitive operation, check whether or not
6833 -- it is a correct dispatching call.
6835 if Is_Overloadable (Nam)
6836 and then Is_Dispatching_Operation (Nam)
6838 Check_Dispatching_Call (N);
6840 elsif Ekind (Nam) /= E_Subprogram_Type
6841 and then Is_Abstract_Subprogram (Nam)
6842 and then not In_Instance
6844 Error_Msg_NE ("cannot call abstract subprogram &!", N, Nam);
6847 -- If this is a dispatching call, generate the appropriate reference,
6848 -- for better source navigation in GNAT Studio.
6850 if Is_Overloadable (Nam)
6851 and then Present (Controlling_Argument (N))
6853 Generate_Reference (Nam, Subp, 'R');
6855 -- Normal case, not a dispatching call: generate a call reference
6858 Generate_Reference (Nam, Subp, 's');
6861 if Is_Intrinsic_Subprogram (Nam) then
6862 Check_Intrinsic_Call (N);
6865 -- Check for violation of restriction No_Specific_Termination_Handlers
6866 -- and warn on a potentially blocking call to Abort_Task.
6868 if Restriction_Check_Required (No_Specific_Termination_Handlers)
6869 and then (Is_RTE (Nam, RE_Set_Specific_Handler)
6871 Is_RTE (Nam, RE_Specific_Handler))
6873 Check_Restriction (No_Specific_Termination_Handlers, N);
6875 elsif Is_RTE (Nam, RE_Abort_Task) then
6876 Check_Potentially_Blocking_Operation (N);
6879 -- A call to Ada.Real_Time.Timing_Events.Set_Handler to set a relative
6880 -- timing event violates restriction No_Relative_Delay (AI-0211). We
6881 -- need to check the second argument to determine whether it is an
6882 -- absolute or relative timing event.
6884 if Restriction_Check_Required (No_Relative_Delay)
6885 and then Is_RTE (Nam, RE_Set_Handler)
6886 and then Is_RTE (Etype (Next_Actual (First_Actual (N))), RE_Time_Span)
6888 Check_Restriction (No_Relative_Delay, N);
6891 -- Issue an error for a call to an eliminated subprogram. This routine
6892 -- will not perform the check if the call appears within a default
6895 Check_For_Eliminated_Subprogram (Subp, Nam);
6897 -- In formal mode, the primitive operations of a tagged type or type
6898 -- extension do not include functions that return the tagged type.
6900 if Nkind (N) = N_Function_Call
6901 and then Is_Tagged_Type (Etype (N))
6902 and then Is_Entity_Name (Name (N))
6903 and then Is_Inherited_Operation_For_Type (Entity (Name (N)), Etype (N))
6905 Check_SPARK_05_Restriction ("function not inherited", N);
6908 -- Implement rule in 12.5.1 (23.3/2): In an instance, if the actual is
6909 -- class-wide and the call dispatches on result in a context that does
6910 -- not provide a tag, the call raises Program_Error.
6912 if Nkind (N) = N_Function_Call
6913 and then In_Instance
6914 and then Is_Generic_Actual_Type (Typ)
6915 and then Is_Class_Wide_Type (Typ)
6916 and then Has_Controlling_Result (Nam)
6917 and then Nkind (Parent (N)) = N_Object_Declaration
6919 -- Verify that none of the formals are controlling
6922 Call_OK : Boolean := False;
6926 F := First_Formal (Nam);
6927 while Present (F) loop
6928 if Is_Controlling_Formal (F) then
6937 Error_Msg_Warn := SPARK_Mode /= On;
6938 Error_Msg_N ("!cannot determine tag of result<<", N);
6939 Error_Msg_N ("\Program_Error [<<!", N);
6941 Make_Raise_Program_Error (Sloc (N),
6942 Reason => PE_Explicit_Raise));
6947 -- Check for calling a function with OUT or IN OUT parameter when the
6948 -- calling context (us right now) is not Ada 2012, so does not allow
6949 -- OUT or IN OUT parameters in function calls. Functions declared in
6950 -- a predefined unit are OK, as they may be called indirectly from a
6951 -- user-declared instantiation.
6953 if Ada_Version < Ada_2012
6954 and then Ekind (Nam) = E_Function
6955 and then Has_Out_Or_In_Out_Parameter (Nam)
6956 and then not In_Predefined_Unit (Nam)
6958 Error_Msg_NE ("& has at least one OUT or `IN OUT` parameter", N, Nam);
6959 Error_Msg_N ("\call to this function only allowed in Ada 2012", N);
6962 -- Check the dimensions of the actuals in the call. For function calls,
6963 -- propagate the dimensions from the returned type to N.
6965 Analyze_Dimension_Call (N, Nam);
6967 -- All done, evaluate call and deal with elaboration issues
6971 if Legacy_Elaboration_Checks then
6972 Check_Elab_Call (N);
6975 -- Annotate the tree by creating a call marker in case the original call
6976 -- is transformed by expansion. The call marker is automatically saved
6977 -- for later examination by the ABE Processing phase.
6979 Build_Call_Marker (N);
6981 Mark_Use_Clauses (Subp);
6983 Warn_On_Overlapping_Actuals (Nam, N);
6985 -- In GNATprove mode, expansion is disabled, but we want to inline some
6986 -- subprograms to facilitate formal verification. Indirect calls through
6987 -- a subprogram type or within a generic cannot be inlined. Inlining is
6988 -- performed only for calls subject to SPARK_Mode on.
6991 and then SPARK_Mode = On
6992 and then Is_Overloadable (Nam)
6993 and then not Inside_A_Generic
6995 Nam_UA := Ultimate_Alias (Nam);
6996 Nam_Decl := Unit_Declaration_Node (Nam_UA);
6998 if Nkind (Nam_Decl) = N_Subprogram_Declaration then
6999 Body_Id := Corresponding_Body (Nam_Decl);
7001 -- Nothing to do if the subprogram is not eligible for inlining in
7002 -- GNATprove mode, or inlining is disabled with switch -gnatdm
7004 if not Is_Inlined_Always (Nam_UA)
7005 or else not Can_Be_Inlined_In_GNATprove_Mode (Nam_UA, Body_Id)
7006 or else Debug_Flag_M
7010 -- Calls cannot be inlined inside assertions, as GNATprove treats
7011 -- assertions as logic expressions. Only issue a message when the
7012 -- body has been seen, otherwise this leads to spurious messages
7013 -- on expression functions.
7015 elsif In_Assertion_Expr /= 0 then
7016 if Present (Body_Id) then
7018 ("cannot inline & (in assertion expression)?", N, Nam_UA);
7021 -- Calls cannot be inlined inside default expressions
7023 elsif In_Default_Expr then
7025 ("cannot inline & (in default expression)?", N, Nam_UA);
7027 -- Calls cannot be inlined inside quantified expressions, which
7028 -- are left in expression form for GNATprove. Since these
7029 -- expressions are only preanalyzed, we need to detect the failure
7030 -- to inline outside of the case for Full_Analysis below.
7032 elsif In_Quantified_Expression (N) then
7034 ("cannot inline & (in quantified expression)?", N, Nam_UA);
7036 -- Inlining should not be performed during preanalysis
7038 elsif Full_Analysis then
7040 -- Do not inline calls inside expression functions or functions
7041 -- generated by the front end for subtype predicates, as this
7042 -- would prevent interpreting them as logical formulas in
7043 -- GNATprove. Only issue a message when the body has been seen,
7044 -- otherwise this leads to spurious messages on callees that
7045 -- are themselves expression functions.
7047 if Present (Current_Subprogram)
7049 (Is_Expression_Function_Or_Completion (Current_Subprogram)
7050 or else Is_Predicate_Function (Current_Subprogram)
7051 or else Is_Invariant_Procedure (Current_Subprogram)
7052 or else Is_DIC_Procedure (Current_Subprogram))
7054 if Present (Body_Id)
7055 and then Present (Body_To_Inline (Nam_Decl))
7057 if Is_Predicate_Function (Current_Subprogram) then
7059 ("cannot inline & (inside predicate)?",
7062 elsif Is_Invariant_Procedure (Current_Subprogram) then
7064 ("cannot inline & (inside invariant)?",
7067 elsif Is_DIC_Procedure (Current_Subprogram) then
7069 ("cannot inline & (inside Default_Initial_Condition)?",
7074 ("cannot inline & (inside expression function)?",
7079 -- Cannot inline a call inside the definition of a record type,
7080 -- typically inside the constraints of the type. Calls in
7081 -- default expressions are also not inlined, but this is
7082 -- filtered out above when testing In_Default_Expr.
7084 elsif Is_Record_Type (Current_Scope) then
7086 ("cannot inline & (inside record type)?", N, Nam_UA);
7088 -- With the one-pass inlining technique, a call cannot be
7089 -- inlined if the corresponding body has not been seen yet.
7091 elsif No (Body_Id) then
7093 ("cannot inline & (body not seen yet)?", N, Nam_UA);
7095 -- Nothing to do if there is no body to inline, indicating that
7096 -- the subprogram is not suitable for inlining in GNATprove
7099 elsif No (Body_To_Inline (Nam_Decl)) then
7102 -- Calls cannot be inlined inside potentially unevaluated
7103 -- expressions, as this would create complex actions inside
7104 -- expressions, that are not handled by GNATprove.
7106 elsif Is_Potentially_Unevaluated (N) then
7108 ("cannot inline & (in potentially unevaluated context)?",
7111 -- Do not inline calls which would possibly lead to missing a
7112 -- type conversion check on an input parameter.
7114 elsif not Call_Can_Be_Inlined_In_GNATprove_Mode (N, Nam) then
7116 ("cannot inline & (possible check on input parameters)?",
7119 -- Otherwise, inline the call, issuing an info message when
7123 if Debug_Flag_Underscore_F then
7125 ("info: analyzing call to & in context?", N, Nam_UA);
7128 Expand_Inlined_Call (N, Nam_UA, Nam);
7135 -----------------------------
7136 -- Resolve_Case_Expression --
7137 -----------------------------
7139 procedure Resolve_Case_Expression (N : Node_Id; Typ : Entity_Id) is
7142 Alt_Typ : Entity_Id;
7146 Alt := First (Alternatives (N));
7147 while Present (Alt) loop
7148 Alt_Expr := Expression (Alt);
7150 if Error_Posted (Alt_Expr) then
7154 Resolve (Alt_Expr, Typ);
7155 Alt_Typ := Etype (Alt_Expr);
7157 -- When the expression is of a scalar subtype different from the
7158 -- result subtype, then insert a conversion to ensure the generation
7159 -- of a constraint check.
7161 if Is_Scalar_Type (Alt_Typ) and then Alt_Typ /= Typ then
7162 Rewrite (Alt_Expr, Convert_To (Typ, Alt_Expr));
7163 Analyze_And_Resolve (Alt_Expr, Typ);
7169 -- Apply RM 4.5.7 (17/3): whether the expression is statically or
7170 -- dynamically tagged must be known statically.
7172 if Is_Tagged_Type (Typ) and then not Is_Class_Wide_Type (Typ) then
7173 Alt := First (Alternatives (N));
7174 Is_Dyn := Is_Dynamically_Tagged (Expression (Alt));
7176 while Present (Alt) loop
7177 if Is_Dynamically_Tagged (Expression (Alt)) /= Is_Dyn then
7179 ("all or none of the dependent expressions can be "
7180 & "dynamically tagged", N);
7188 Eval_Case_Expression (N);
7189 Analyze_Dimension (N);
7190 end Resolve_Case_Expression;
7192 -------------------------------
7193 -- Resolve_Character_Literal --
7194 -------------------------------
7196 procedure Resolve_Character_Literal (N : Node_Id; Typ : Entity_Id) is
7197 B_Typ : constant Entity_Id := Base_Type (Typ);
7201 -- Verify that the character does belong to the type of the context
7203 Set_Etype (N, B_Typ);
7204 Eval_Character_Literal (N);
7206 -- Wide_Wide_Character literals must always be defined, since the set
7207 -- of wide wide character literals is complete, i.e. if a character
7208 -- literal is accepted by the parser, then it is OK for wide wide
7209 -- character (out of range character literals are rejected).
7211 if Root_Type (B_Typ) = Standard_Wide_Wide_Character then
7214 -- Always accept character literal for type Any_Character, which
7215 -- occurs in error situations and in comparisons of literals, both
7216 -- of which should accept all literals.
7218 elsif B_Typ = Any_Character then
7221 -- For Standard.Character or a type derived from it, check that the
7222 -- literal is in range.
7224 elsif Root_Type (B_Typ) = Standard_Character then
7225 if In_Character_Range (UI_To_CC (Char_Literal_Value (N))) then
7229 -- For Standard.Wide_Character or a type derived from it, check that the
7230 -- literal is in range.
7232 elsif Root_Type (B_Typ) = Standard_Wide_Character then
7233 if In_Wide_Character_Range (UI_To_CC (Char_Literal_Value (N))) then
7237 -- If the entity is already set, this has already been resolved in a
7238 -- generic context, or comes from expansion. Nothing else to do.
7240 elsif Present (Entity (N)) then
7243 -- Otherwise we have a user defined character type, and we can use the
7244 -- standard visibility mechanisms to locate the referenced entity.
7247 C := Current_Entity (N);
7248 while Present (C) loop
7249 if Etype (C) = B_Typ then
7250 Set_Entity_With_Checks (N, C);
7251 Generate_Reference (C, N);
7259 -- If we fall through, then the literal does not match any of the
7260 -- entries of the enumeration type. This isn't just a constraint error
7261 -- situation, it is an illegality (see RM 4.2).
7264 ("character not defined for }", N, First_Subtype (B_Typ));
7265 end Resolve_Character_Literal;
7267 ---------------------------
7268 -- Resolve_Comparison_Op --
7269 ---------------------------
7271 -- Context requires a boolean type, and plays no role in resolution.
7272 -- Processing identical to that for equality operators. The result type is
7273 -- the base type, which matters when pathological subtypes of booleans with
7274 -- limited ranges are used.
7276 procedure Resolve_Comparison_Op (N : Node_Id; Typ : Entity_Id) is
7277 L : constant Node_Id := Left_Opnd (N);
7278 R : constant Node_Id := Right_Opnd (N);
7282 -- If this is an intrinsic operation which is not predefined, use the
7283 -- types of its declared arguments to resolve the possibly overloaded
7284 -- operands. Otherwise the operands are unambiguous and specify the
7287 if Scope (Entity (N)) /= Standard_Standard then
7288 T := Etype (First_Entity (Entity (N)));
7291 T := Find_Unique_Type (L, R);
7293 if T = Any_Fixed then
7294 T := Unique_Fixed_Point_Type (L);
7298 Set_Etype (N, Base_Type (Typ));
7299 Generate_Reference (T, N, ' ');
7301 -- Skip remaining processing if already set to Any_Type
7303 if T = Any_Type then
7307 -- Deal with other error cases
7309 if T = Any_String or else
7310 T = Any_Composite or else
7313 if T = Any_Character then
7314 Ambiguous_Character (L);
7316 Error_Msg_N ("ambiguous operands for comparison", N);
7319 Set_Etype (N, Any_Type);
7323 -- Resolve the operands if types OK
7327 Check_Unset_Reference (L);
7328 Check_Unset_Reference (R);
7329 Generate_Operator_Reference (N, T);
7330 Check_Low_Bound_Tested (N);
7332 -- In SPARK, ordering operators <, <=, >, >= are not defined for Boolean
7333 -- types or array types except String.
7335 if Is_Boolean_Type (T) then
7336 Check_SPARK_05_Restriction
7337 ("comparison is not defined on Boolean type", N);
7339 elsif Is_Array_Type (T)
7340 and then Base_Type (T) /= Standard_String
7342 Check_SPARK_05_Restriction
7343 ("comparison is not defined on array types other than String", N);
7346 -- Check comparison on unordered enumeration
7348 if Bad_Unordered_Enumeration_Reference (N, Etype (L)) then
7349 Error_Msg_Sloc := Sloc (Etype (L));
7351 ("comparison on unordered enumeration type& declared#?U?",
7355 Analyze_Dimension (N);
7357 -- Evaluate the relation (note we do this after the above check since
7358 -- this Eval call may change N to True/False. Skip this evaluation
7359 -- inside assertions, in order to keep assertions as written by users
7360 -- for tools that rely on these, e.g. GNATprove for loop invariants.
7361 -- Except evaluation is still performed even inside assertions for
7362 -- comparisons between values of universal type, which are useless
7363 -- for static analysis tools, and not supported even by GNATprove.
7365 if In_Assertion_Expr = 0
7366 or else (Is_Universal_Numeric_Type (Etype (L))
7368 Is_Universal_Numeric_Type (Etype (R)))
7370 Eval_Relational_Op (N);
7372 end Resolve_Comparison_Op;
7374 -----------------------------------------
7375 -- Resolve_Discrete_Subtype_Indication --
7376 -----------------------------------------
7378 procedure Resolve_Discrete_Subtype_Indication
7386 Analyze (Subtype_Mark (N));
7387 S := Entity (Subtype_Mark (N));
7389 if Nkind (Constraint (N)) /= N_Range_Constraint then
7390 Error_Msg_N ("expect range constraint for discrete type", N);
7391 Set_Etype (N, Any_Type);
7394 R := Range_Expression (Constraint (N));
7402 if Base_Type (S) /= Base_Type (Typ) then
7404 ("expect subtype of }", N, First_Subtype (Typ));
7406 -- Rewrite the constraint as a range of Typ
7407 -- to allow compilation to proceed further.
7410 Rewrite (Low_Bound (R),
7411 Make_Attribute_Reference (Sloc (Low_Bound (R)),
7412 Prefix => New_Occurrence_Of (Typ, Sloc (R)),
7413 Attribute_Name => Name_First));
7414 Rewrite (High_Bound (R),
7415 Make_Attribute_Reference (Sloc (High_Bound (R)),
7416 Prefix => New_Occurrence_Of (Typ, Sloc (R)),
7417 Attribute_Name => Name_First));
7421 Set_Etype (N, Etype (R));
7423 -- Additionally, we must check that the bounds are compatible
7424 -- with the given subtype, which might be different from the
7425 -- type of the context.
7427 Apply_Range_Check (R, S);
7429 -- ??? If the above check statically detects a Constraint_Error
7430 -- it replaces the offending bound(s) of the range R with a
7431 -- Constraint_Error node. When the itype which uses these bounds
7432 -- is frozen the resulting call to Duplicate_Subexpr generates
7433 -- a new temporary for the bounds.
7435 -- Unfortunately there are other itypes that are also made depend
7436 -- on these bounds, so when Duplicate_Subexpr is called they get
7437 -- a forward reference to the newly created temporaries and Gigi
7438 -- aborts on such forward references. This is probably sign of a
7439 -- more fundamental problem somewhere else in either the order of
7440 -- itype freezing or the way certain itypes are constructed.
7442 -- To get around this problem we call Remove_Side_Effects right
7443 -- away if either bounds of R are a Constraint_Error.
7446 L : constant Node_Id := Low_Bound (R);
7447 H : constant Node_Id := High_Bound (R);
7450 if Nkind (L) = N_Raise_Constraint_Error then
7451 Remove_Side_Effects (L);
7454 if Nkind (H) = N_Raise_Constraint_Error then
7455 Remove_Side_Effects (H);
7459 Check_Unset_Reference (Low_Bound (R));
7460 Check_Unset_Reference (High_Bound (R));
7463 end Resolve_Discrete_Subtype_Indication;
7465 -------------------------
7466 -- Resolve_Entity_Name --
7467 -------------------------
7469 -- Used to resolve identifiers and expanded names
7471 procedure Resolve_Entity_Name (N : Node_Id; Typ : Entity_Id) is
7472 function Is_Assignment_Or_Object_Expression
7474 Expr : Node_Id) return Boolean;
7475 -- Determine whether node Context denotes an assignment statement or an
7476 -- object declaration whose expression is node Expr.
7478 ----------------------------------------
7479 -- Is_Assignment_Or_Object_Expression --
7480 ----------------------------------------
7482 function Is_Assignment_Or_Object_Expression
7484 Expr : Node_Id) return Boolean
7487 if Nkind_In (Context, N_Assignment_Statement,
7488 N_Object_Declaration)
7489 and then Expression (Context) = Expr
7493 -- Check whether a construct that yields a name is the expression of
7494 -- an assignment statement or an object declaration.
7496 elsif (Nkind_In (Context, N_Attribute_Reference,
7497 N_Explicit_Dereference,
7498 N_Indexed_Component,
7499 N_Selected_Component,
7501 and then Prefix (Context) = Expr)
7503 (Nkind_In (Context, N_Type_Conversion,
7504 N_Unchecked_Type_Conversion)
7505 and then Expression (Context) = Expr)
7508 Is_Assignment_Or_Object_Expression
7509 (Context => Parent (Context),
7512 -- Otherwise the context is not an assignment statement or an object
7518 end Is_Assignment_Or_Object_Expression;
7522 E : constant Entity_Id := Entity (N);
7525 -- Start of processing for Resolve_Entity_Name
7528 -- If garbage from errors, set to Any_Type and return
7530 if No (E) and then Total_Errors_Detected /= 0 then
7531 Set_Etype (N, Any_Type);
7535 -- Replace named numbers by corresponding literals. Note that this is
7536 -- the one case where Resolve_Entity_Name must reset the Etype, since
7537 -- it is currently marked as universal.
7539 if Ekind (E) = E_Named_Integer then
7541 Eval_Named_Integer (N);
7543 elsif Ekind (E) = E_Named_Real then
7545 Eval_Named_Real (N);
7547 -- For enumeration literals, we need to make sure that a proper style
7548 -- check is done, since such literals are overloaded, and thus we did
7549 -- not do a style check during the first phase of analysis.
7551 elsif Ekind (E) = E_Enumeration_Literal then
7552 Set_Entity_With_Checks (N, E);
7553 Eval_Entity_Name (N);
7555 -- Case of (sub)type name appearing in a context where an expression
7556 -- is expected. This is legal if occurrence is a current instance.
7557 -- See RM 8.6 (17/3).
7559 elsif Is_Type (E) then
7560 if Is_Current_Instance (N) then
7563 -- Any other use is an error
7567 ("invalid use of subtype mark in expression or call", N);
7570 -- Check discriminant use if entity is discriminant in current scope,
7571 -- i.e. discriminant of record or concurrent type currently being
7572 -- analyzed. Uses in corresponding body are unrestricted.
7574 elsif Ekind (E) = E_Discriminant
7575 and then Scope (E) = Current_Scope
7576 and then not Has_Completion (Current_Scope)
7578 Check_Discriminant_Use (N);
7580 -- A parameterless generic function cannot appear in a context that
7581 -- requires resolution.
7583 elsif Ekind (E) = E_Generic_Function then
7584 Error_Msg_N ("illegal use of generic function", N);
7586 -- In Ada 83 an OUT parameter cannot be read, but attributes of
7587 -- array types (i.e. bounds and length) are legal.
7589 elsif Ekind (E) = E_Out_Parameter
7590 and then (Nkind (Parent (N)) /= N_Attribute_Reference
7591 or else Is_Scalar_Type (Etype (E)))
7593 and then (Nkind (Parent (N)) in N_Op
7594 or else Nkind (Parent (N)) = N_Explicit_Dereference
7595 or else Is_Assignment_Or_Object_Expression
7596 (Context => Parent (N),
7599 if Ada_Version = Ada_83 then
7600 Error_Msg_N ("(Ada 83) illegal reading of out parameter", N);
7603 -- In all other cases, just do the possible static evaluation
7606 -- A deferred constant that appears in an expression must have a
7607 -- completion, unless it has been removed by in-place expansion of
7608 -- an aggregate. A constant that is a renaming does not need
7611 if Ekind (E) = E_Constant
7612 and then Comes_From_Source (E)
7613 and then No (Constant_Value (E))
7614 and then Is_Frozen (Etype (E))
7615 and then not In_Spec_Expression
7616 and then not Is_Imported (E)
7617 and then Nkind (Parent (E)) /= N_Object_Renaming_Declaration
7619 if No_Initialization (Parent (E))
7620 or else (Present (Full_View (E))
7621 and then No_Initialization (Parent (Full_View (E))))
7626 ("deferred constant is frozen before completion", N);
7630 Eval_Entity_Name (N);
7635 -- When the entity appears in a parameter association, retrieve the
7636 -- related subprogram call.
7638 if Nkind (Par) = N_Parameter_Association then
7639 Par := Parent (Par);
7642 if Comes_From_Source (N) then
7644 -- The following checks are only relevant when SPARK_Mode is on as
7645 -- they are not standard Ada legality rules.
7647 if SPARK_Mode = On then
7649 -- An effectively volatile object subject to enabled properties
7650 -- Async_Writers or Effective_Reads must appear in non-interfering
7651 -- context (SPARK RM 7.1.3(12)).
7654 and then Is_Effectively_Volatile (E)
7655 and then (Async_Writers_Enabled (E)
7656 or else Effective_Reads_Enabled (E))
7657 and then not Is_OK_Volatile_Context (Par, N)
7660 ("volatile object cannot appear in this context "
7661 & "(SPARK RM 7.1.3(12))", N);
7664 -- Check for possible elaboration issues with respect to reads of
7665 -- variables. The act of renaming the variable is not considered a
7666 -- read as it simply establishes an alias.
7668 if Legacy_Elaboration_Checks
7669 and then Ekind (E) = E_Variable
7670 and then Dynamic_Elaboration_Checks
7671 and then Nkind (Par) /= N_Object_Renaming_Declaration
7673 Check_Elab_Call (N);
7677 -- The variable may eventually become a constituent of a single
7678 -- protected/task type. Record the reference now and verify its
7679 -- legality when analyzing the contract of the variable
7682 if Ekind (E) = E_Variable then
7683 Record_Possible_Part_Of_Reference (E, N);
7686 -- A Ghost entity must appear in a specific context
7688 if Is_Ghost_Entity (E) then
7689 Check_Ghost_Context (E, N);
7693 -- We may be resolving an entity within expanded code, so a reference to
7694 -- an entity should be ignored when calculating effective use clauses to
7695 -- avoid inappropriate marking.
7697 if Comes_From_Source (N) then
7698 Mark_Use_Clauses (E);
7700 end Resolve_Entity_Name;
7706 procedure Resolve_Entry (Entry_Name : Node_Id) is
7707 Loc : constant Source_Ptr := Sloc (Entry_Name);
7715 function Actual_Index_Type (E : Entity_Id) return Entity_Id;
7716 -- If the bounds of the entry family being called depend on task
7717 -- discriminants, build a new index subtype where a discriminant is
7718 -- replaced with the value of the discriminant of the target task.
7719 -- The target task is the prefix of the entry name in the call.
7721 -----------------------
7722 -- Actual_Index_Type --
7723 -----------------------
7725 function Actual_Index_Type (E : Entity_Id) return Entity_Id is
7726 Typ : constant Entity_Id := Entry_Index_Type (E);
7727 Tsk : constant Entity_Id := Scope (E);
7728 Lo : constant Node_Id := Type_Low_Bound (Typ);
7729 Hi : constant Node_Id := Type_High_Bound (Typ);
7732 function Actual_Discriminant_Ref (Bound : Node_Id) return Node_Id;
7733 -- If the bound is given by a discriminant, replace with a reference
7734 -- to the discriminant of the same name in the target task. If the
7735 -- entry name is the target of a requeue statement and the entry is
7736 -- in the current protected object, the bound to be used is the
7737 -- discriminal of the object (see Apply_Range_Checks for details of
7738 -- the transformation).
7740 -----------------------------
7741 -- Actual_Discriminant_Ref --
7742 -----------------------------
7744 function Actual_Discriminant_Ref (Bound : Node_Id) return Node_Id is
7745 Typ : constant Entity_Id := Etype (Bound);
7749 Remove_Side_Effects (Bound);
7751 if not Is_Entity_Name (Bound)
7752 or else Ekind (Entity (Bound)) /= E_Discriminant
7756 elsif Is_Protected_Type (Tsk)
7757 and then In_Open_Scopes (Tsk)
7758 and then Nkind (Parent (Entry_Name)) = N_Requeue_Statement
7760 -- Note: here Bound denotes a discriminant of the corresponding
7761 -- record type tskV, whose discriminal is a formal of the
7762 -- init-proc tskVIP. What we want is the body discriminal,
7763 -- which is associated to the discriminant of the original
7764 -- concurrent type tsk.
7766 return New_Occurrence_Of
7767 (Find_Body_Discriminal (Entity (Bound)), Loc);
7771 Make_Selected_Component (Loc,
7772 Prefix => New_Copy_Tree (Prefix (Prefix (Entry_Name))),
7773 Selector_Name => New_Occurrence_Of (Entity (Bound), Loc));
7778 end Actual_Discriminant_Ref;
7780 -- Start of processing for Actual_Index_Type
7783 if not Has_Discriminants (Tsk)
7784 or else (not Is_Entity_Name (Lo) and then not Is_Entity_Name (Hi))
7786 return Entry_Index_Type (E);
7789 New_T := Create_Itype (Ekind (Typ), Parent (Entry_Name));
7790 Set_Etype (New_T, Base_Type (Typ));
7791 Set_Size_Info (New_T, Typ);
7792 Set_RM_Size (New_T, RM_Size (Typ));
7793 Set_Scalar_Range (New_T,
7794 Make_Range (Sloc (Entry_Name),
7795 Low_Bound => Actual_Discriminant_Ref (Lo),
7796 High_Bound => Actual_Discriminant_Ref (Hi)));
7800 end Actual_Index_Type;
7802 -- Start of processing for Resolve_Entry
7805 -- Find name of entry being called, and resolve prefix of name with its
7806 -- own type. The prefix can be overloaded, and the name and signature of
7807 -- the entry must be taken into account.
7809 if Nkind (Entry_Name) = N_Indexed_Component then
7811 -- Case of dealing with entry family within the current tasks
7813 E_Name := Prefix (Entry_Name);
7816 E_Name := Entry_Name;
7819 if Is_Entity_Name (E_Name) then
7821 -- Entry call to an entry (or entry family) in the current task. This
7822 -- is legal even though the task will deadlock. Rewrite as call to
7825 -- This can also be a call to an entry in an enclosing task. If this
7826 -- is a single task, we have to retrieve its name, because the scope
7827 -- of the entry is the task type, not the object. If the enclosing
7828 -- task is a task type, the identity of the task is given by its own
7831 -- Finally this can be a requeue on an entry of the same task or
7832 -- protected object.
7834 S := Scope (Entity (E_Name));
7836 for J in reverse 0 .. Scope_Stack.Last loop
7837 if Is_Task_Type (Scope_Stack.Table (J).Entity)
7838 and then not Comes_From_Source (S)
7840 -- S is an enclosing task or protected object. The concurrent
7841 -- declaration has been converted into a type declaration, and
7842 -- the object itself has an object declaration that follows
7843 -- the type in the same declarative part.
7845 Tsk := Next_Entity (S);
7846 while Etype (Tsk) /= S loop
7853 elsif S = Scope_Stack.Table (J).Entity then
7855 -- Call to current task. Will be transformed into call to Self
7863 Make_Selected_Component (Loc,
7864 Prefix => New_Occurrence_Of (S, Loc),
7866 New_Occurrence_Of (Entity (E_Name), Loc));
7867 Rewrite (E_Name, New_N);
7870 elsif Nkind (Entry_Name) = N_Selected_Component
7871 and then Is_Overloaded (Prefix (Entry_Name))
7873 -- Use the entry name (which must be unique at this point) to find
7874 -- the prefix that returns the corresponding task/protected type.
7877 Pref : constant Node_Id := Prefix (Entry_Name);
7878 Ent : constant Entity_Id := Entity (Selector_Name (Entry_Name));
7883 Get_First_Interp (Pref, I, It);
7884 while Present (It.Typ) loop
7885 if Scope (Ent) = It.Typ then
7886 Set_Etype (Pref, It.Typ);
7890 Get_Next_Interp (I, It);
7895 if Nkind (Entry_Name) = N_Selected_Component then
7896 Resolve (Prefix (Entry_Name));
7898 else pragma Assert (Nkind (Entry_Name) = N_Indexed_Component);
7899 Nam := Entity (Selector_Name (Prefix (Entry_Name)));
7900 Resolve (Prefix (Prefix (Entry_Name)));
7901 Index := First (Expressions (Entry_Name));
7902 Resolve (Index, Entry_Index_Type (Nam));
7904 -- Generate a reference for the index when it denotes an entity
7906 if Is_Entity_Name (Index) then
7907 Generate_Reference (Entity (Index), Nam);
7910 -- Up to this point the expression could have been the actual in a
7911 -- simple entry call, and be given by a named association.
7913 if Nkind (Index) = N_Parameter_Association then
7914 Error_Msg_N ("expect expression for entry index", Index);
7916 Apply_Range_Check (Index, Actual_Index_Type (Nam));
7921 ------------------------
7922 -- Resolve_Entry_Call --
7923 ------------------------
7925 procedure Resolve_Entry_Call (N : Node_Id; Typ : Entity_Id) is
7926 Entry_Name : constant Node_Id := Name (N);
7927 Loc : constant Source_Ptr := Sloc (Entry_Name);
7935 -- We kill all checks here, because it does not seem worth the effort to
7936 -- do anything better, an entry call is a big operation.
7940 -- Processing of the name is similar for entry calls and protected
7941 -- operation calls. Once the entity is determined, we can complete
7942 -- the resolution of the actuals.
7944 -- The selector may be overloaded, in the case of a protected object
7945 -- with overloaded functions. The type of the context is used for
7948 if Nkind (Entry_Name) = N_Selected_Component
7949 and then Is_Overloaded (Selector_Name (Entry_Name))
7950 and then Typ /= Standard_Void_Type
7957 Get_First_Interp (Selector_Name (Entry_Name), I, It);
7958 while Present (It.Typ) loop
7959 if Covers (Typ, It.Typ) then
7960 Set_Entity (Selector_Name (Entry_Name), It.Nam);
7961 Set_Etype (Entry_Name, It.Typ);
7963 Generate_Reference (It.Typ, N, ' ');
7966 Get_Next_Interp (I, It);
7971 Resolve_Entry (Entry_Name);
7973 if Nkind (Entry_Name) = N_Selected_Component then
7975 -- Simple entry or protected operation call
7977 Nam := Entity (Selector_Name (Entry_Name));
7978 Obj := Prefix (Entry_Name);
7980 if Is_Subprogram (Nam) then
7981 Check_For_Eliminated_Subprogram (Entry_Name, Nam);
7984 Was_Over := Is_Overloaded (Selector_Name (Entry_Name));
7986 else pragma Assert (Nkind (Entry_Name) = N_Indexed_Component);
7988 -- Call to member of entry family
7990 Nam := Entity (Selector_Name (Prefix (Entry_Name)));
7991 Obj := Prefix (Prefix (Entry_Name));
7992 Was_Over := Is_Overloaded (Selector_Name (Prefix (Entry_Name)));
7995 -- We cannot in general check the maximum depth of protected entry calls
7996 -- at compile time. But we can tell that any protected entry call at all
7997 -- violates a specified nesting depth of zero.
7999 if Is_Protected_Type (Scope (Nam)) then
8000 Check_Restriction (Max_Entry_Queue_Length, N);
8003 -- Use context type to disambiguate a protected function that can be
8004 -- called without actuals and that returns an array type, and where the
8005 -- argument list may be an indexing of the returned value.
8007 if Ekind (Nam) = E_Function
8008 and then Needs_No_Actuals (Nam)
8009 and then Present (Parameter_Associations (N))
8011 ((Is_Array_Type (Etype (Nam))
8012 and then Covers (Typ, Component_Type (Etype (Nam))))
8014 or else (Is_Access_Type (Etype (Nam))
8015 and then Is_Array_Type (Designated_Type (Etype (Nam)))
8019 Component_Type (Designated_Type (Etype (Nam))))))
8022 Index_Node : Node_Id;
8026 Make_Indexed_Component (Loc,
8028 Make_Function_Call (Loc, Name => Relocate_Node (Entry_Name)),
8029 Expressions => Parameter_Associations (N));
8031 -- Since we are correcting a node classification error made by the
8032 -- parser, we call Replace rather than Rewrite.
8034 Replace (N, Index_Node);
8035 Set_Etype (Prefix (N), Etype (Nam));
8037 Resolve_Indexed_Component (N, Typ);
8042 if Ekind_In (Nam, E_Entry, E_Entry_Family)
8043 and then Present (Contract_Wrapper (Nam))
8044 and then Current_Scope /= Contract_Wrapper (Nam)
8046 -- Note the entity being called before rewriting the call, so that
8047 -- it appears used at this point.
8049 Generate_Reference (Nam, Entry_Name, 'r');
8051 -- Rewrite as call to the precondition wrapper, adding the task
8052 -- object to the list of actuals. If the call is to a member of an
8053 -- entry family, include the index as well.
8057 New_Actuals : List_Id;
8060 New_Actuals := New_List (Obj);
8062 if Nkind (Entry_Name) = N_Indexed_Component then
8063 Append_To (New_Actuals,
8064 New_Copy_Tree (First (Expressions (Entry_Name))));
8067 Append_List (Parameter_Associations (N), New_Actuals);
8069 Make_Procedure_Call_Statement (Loc,
8071 New_Occurrence_Of (Contract_Wrapper (Nam), Loc),
8072 Parameter_Associations => New_Actuals);
8073 Rewrite (N, New_Call);
8075 -- Preanalyze and resolve new call. Current procedure is called
8076 -- from Resolve_Call, after which expansion will take place.
8078 Preanalyze_And_Resolve (N);
8083 -- The operation name may have been overloaded. Order the actuals
8084 -- according to the formals of the resolved entity, and set the return
8085 -- type to that of the operation.
8088 Normalize_Actuals (N, Nam, False, Norm_OK);
8089 pragma Assert (Norm_OK);
8090 Set_Etype (N, Etype (Nam));
8092 -- Reset the Is_Overloaded flag, since resolution is now completed
8094 -- Simple entry call
8096 if Nkind (Entry_Name) = N_Selected_Component then
8097 Set_Is_Overloaded (Selector_Name (Entry_Name), False);
8099 -- Call to a member of an entry family
8101 else pragma Assert (Nkind (Entry_Name) = N_Indexed_Component);
8102 Set_Is_Overloaded (Selector_Name (Prefix (Entry_Name)), False);
8106 Resolve_Actuals (N, Nam);
8107 Check_Internal_Protected_Use (N, Nam);
8109 -- Create a call reference to the entry
8111 Generate_Reference (Nam, Entry_Name, 's');
8113 if Ekind_In (Nam, E_Entry, E_Entry_Family) then
8114 Check_Potentially_Blocking_Operation (N);
8117 -- Verify that a procedure call cannot masquerade as an entry
8118 -- call where an entry call is expected.
8120 if Ekind (Nam) = E_Procedure then
8121 if Nkind (Parent (N)) = N_Entry_Call_Alternative
8122 and then N = Entry_Call_Statement (Parent (N))
8124 Error_Msg_N ("entry call required in select statement", N);
8126 elsif Nkind (Parent (N)) = N_Triggering_Alternative
8127 and then N = Triggering_Statement (Parent (N))
8129 Error_Msg_N ("triggering statement cannot be procedure call", N);
8131 elsif Ekind (Scope (Nam)) = E_Task_Type
8132 and then not In_Open_Scopes (Scope (Nam))
8134 Error_Msg_N ("task has no entry with this name", Entry_Name);
8138 -- After resolution, entry calls and protected procedure calls are
8139 -- changed into entry calls, for expansion. The structure of the node
8140 -- does not change, so it can safely be done in place. Protected
8141 -- function calls must keep their structure because they are
8144 if Ekind (Nam) /= E_Function then
8146 -- A protected operation that is not a function may modify the
8147 -- corresponding object, and cannot apply to a constant. If this
8148 -- is an internal call, the prefix is the type itself.
8150 if Is_Protected_Type (Scope (Nam))
8151 and then not Is_Variable (Obj)
8152 and then (not Is_Entity_Name (Obj)
8153 or else not Is_Type (Entity (Obj)))
8156 ("prefix of protected procedure or entry call must be variable",
8161 Entry_Call : Node_Id;
8165 Make_Entry_Call_Statement (Loc,
8167 Parameter_Associations => Parameter_Associations (N));
8169 -- Inherit relevant attributes from the original call
8171 Set_First_Named_Actual
8172 (Entry_Call, First_Named_Actual (N));
8174 Set_Is_Elaboration_Checks_OK_Node
8175 (Entry_Call, Is_Elaboration_Checks_OK_Node (N));
8177 Set_Is_Elaboration_Warnings_OK_Node
8178 (Entry_Call, Is_Elaboration_Warnings_OK_Node (N));
8180 Set_Is_SPARK_Mode_On_Node
8181 (Entry_Call, Is_SPARK_Mode_On_Node (N));
8183 Rewrite (N, Entry_Call);
8184 Set_Analyzed (N, True);
8187 -- Protected functions can return on the secondary stack, in which case
8188 -- we must trigger the transient scope mechanism.
8190 elsif Expander_Active
8191 and then Requires_Transient_Scope (Etype (Nam))
8193 Establish_Transient_Scope (N, Manage_Sec_Stack => True);
8195 end Resolve_Entry_Call;
8197 -------------------------
8198 -- Resolve_Equality_Op --
8199 -------------------------
8201 -- Both arguments must have the same type, and the boolean context does
8202 -- not participate in the resolution. The first pass verifies that the
8203 -- interpretation is not ambiguous, and the type of the left argument is
8204 -- correctly set, or is Any_Type in case of ambiguity. If both arguments
8205 -- are strings or aggregates, allocators, or Null, they are ambiguous even
8206 -- though they carry a single (universal) type. Diagnose this case here.
8208 procedure Resolve_Equality_Op (N : Node_Id; Typ : Entity_Id) is
8209 L : constant Node_Id := Left_Opnd (N);
8210 R : constant Node_Id := Right_Opnd (N);
8211 T : Entity_Id := Find_Unique_Type (L, R);
8213 procedure Check_If_Expression (Cond : Node_Id);
8214 -- The resolution rule for if expressions requires that each such must
8215 -- have a unique type. This means that if several dependent expressions
8216 -- are of a non-null anonymous access type, and the context does not
8217 -- impose an expected type (as can be the case in an equality operation)
8218 -- the expression must be rejected.
8220 procedure Explain_Redundancy (N : Node_Id);
8221 -- Attempt to explain the nature of a redundant comparison with True. If
8222 -- the expression N is too complex, this routine issues a general error
8225 function Find_Unique_Access_Type return Entity_Id;
8226 -- In the case of allocators and access attributes, the context must
8227 -- provide an indication of the specific access type to be used. If
8228 -- one operand is of such a "generic" access type, check whether there
8229 -- is a specific visible access type that has the same designated type.
8230 -- This is semantically dubious, and of no interest to any real code,
8231 -- but c48008a makes it all worthwhile.
8233 -------------------------
8234 -- Check_If_Expression --
8235 -------------------------
8237 procedure Check_If_Expression (Cond : Node_Id) is
8238 Then_Expr : Node_Id;
8239 Else_Expr : Node_Id;
8242 if Nkind (Cond) = N_If_Expression then
8243 Then_Expr := Next (First (Expressions (Cond)));
8244 Else_Expr := Next (Then_Expr);
8246 if Nkind (Then_Expr) /= N_Null
8247 and then Nkind (Else_Expr) /= N_Null
8249 Error_Msg_N ("cannot determine type of if expression", Cond);
8252 end Check_If_Expression;
8254 ------------------------
8255 -- Explain_Redundancy --
8256 ------------------------
8258 procedure Explain_Redundancy (N : Node_Id) is
8266 -- Strip the operand down to an entity
8269 if Nkind (Val) = N_Selected_Component then
8270 Val := Selector_Name (Val);
8276 -- The construct denotes an entity
8278 if Is_Entity_Name (Val) and then Present (Entity (Val)) then
8279 Val_Id := Entity (Val);
8281 -- Do not generate an error message when the comparison is done
8282 -- against the enumeration literal Standard.True.
8284 if Ekind (Val_Id) /= E_Enumeration_Literal then
8286 -- Build a customized error message
8289 Add_Str_To_Name_Buffer ("?r?");
8291 if Ekind (Val_Id) = E_Component then
8292 Add_Str_To_Name_Buffer ("component ");
8294 elsif Ekind (Val_Id) = E_Constant then
8295 Add_Str_To_Name_Buffer ("constant ");
8297 elsif Ekind (Val_Id) = E_Discriminant then
8298 Add_Str_To_Name_Buffer ("discriminant ");
8300 elsif Is_Formal (Val_Id) then
8301 Add_Str_To_Name_Buffer ("parameter ");
8303 elsif Ekind (Val_Id) = E_Variable then
8304 Add_Str_To_Name_Buffer ("variable ");
8307 Add_Str_To_Name_Buffer ("& is always True!");
8310 Error_Msg_NE (Get_Name_String (Error), Val, Val_Id);
8313 -- The construct is too complex to disect, issue a general message
8316 Error_Msg_N ("?r?expression is always True!", Val);
8318 end Explain_Redundancy;
8320 -----------------------------
8321 -- Find_Unique_Access_Type --
8322 -----------------------------
8324 function Find_Unique_Access_Type return Entity_Id is
8330 if Ekind_In (Etype (R), E_Allocator_Type,
8331 E_Access_Attribute_Type)
8333 Acc := Designated_Type (Etype (R));
8335 elsif Ekind_In (Etype (L), E_Allocator_Type,
8336 E_Access_Attribute_Type)
8338 Acc := Designated_Type (Etype (L));
8344 while S /= Standard_Standard loop
8345 E := First_Entity (S);
8346 while Present (E) loop
8348 and then Is_Access_Type (E)
8349 and then Ekind (E) /= E_Allocator_Type
8350 and then Designated_Type (E) = Base_Type (Acc)
8362 end Find_Unique_Access_Type;
8364 -- Start of processing for Resolve_Equality_Op
8367 Set_Etype (N, Base_Type (Typ));
8368 Generate_Reference (T, N, ' ');
8370 if T = Any_Fixed then
8371 T := Unique_Fixed_Point_Type (L);
8374 if T /= Any_Type then
8375 if T = Any_String or else
8376 T = Any_Composite or else
8379 if T = Any_Character then
8380 Ambiguous_Character (L);
8382 Error_Msg_N ("ambiguous operands for equality", N);
8385 Set_Etype (N, Any_Type);
8388 elsif T = Any_Access
8389 or else Ekind_In (T, E_Allocator_Type, E_Access_Attribute_Type)
8391 T := Find_Unique_Access_Type;
8394 Error_Msg_N ("ambiguous operands for equality", N);
8395 Set_Etype (N, Any_Type);
8399 -- If expressions must have a single type, and if the context does
8400 -- not impose one the dependent expressions cannot be anonymous
8403 -- Why no similar processing for case expressions???
8405 elsif Ada_Version >= Ada_2012
8406 and then Ekind_In (Etype (L), E_Anonymous_Access_Type,
8407 E_Anonymous_Access_Subprogram_Type)
8408 and then Ekind_In (Etype (R), E_Anonymous_Access_Type,
8409 E_Anonymous_Access_Subprogram_Type)
8411 Check_If_Expression (L);
8412 Check_If_Expression (R);
8418 -- In SPARK, equality operators = and /= for array types other than
8419 -- String are only defined when, for each index position, the
8420 -- operands have equal static bounds.
8422 if Is_Array_Type (T) then
8424 -- Protect call to Matching_Static_Array_Bounds to avoid costly
8425 -- operation if not needed.
8427 if Restriction_Check_Required (SPARK_05)
8428 and then Base_Type (T) /= Standard_String
8429 and then Base_Type (Etype (L)) = Base_Type (Etype (R))
8430 and then Etype (L) /= Any_Composite -- or else L in error
8431 and then Etype (R) /= Any_Composite -- or else R in error
8432 and then not Matching_Static_Array_Bounds (Etype (L), Etype (R))
8434 Check_SPARK_05_Restriction
8435 ("array types should have matching static bounds", N);
8439 -- If the unique type is a class-wide type then it will be expanded
8440 -- into a dispatching call to the predefined primitive. Therefore we
8441 -- check here for potential violation of such restriction.
8443 if Is_Class_Wide_Type (T) then
8444 Check_Restriction (No_Dispatching_Calls, N);
8447 -- Only warn for redundant equality comparison to True for objects
8448 -- (e.g. "X = True") and operations (e.g. "(X < Y) = True"). For
8449 -- other expressions, it may be a matter of preference to write
8450 -- "Expr = True" or "Expr".
8452 if Warn_On_Redundant_Constructs
8453 and then Comes_From_Source (N)
8454 and then Comes_From_Source (R)
8455 and then Is_Entity_Name (R)
8456 and then Entity (R) = Standard_True
8458 ((Is_Entity_Name (L) and then Is_Object (Entity (L)))
8462 Error_Msg_N -- CODEFIX
8463 ("?r?comparison with True is redundant!", N);
8464 Explain_Redundancy (Original_Node (R));
8467 -- If the equality is overloaded and the operands have resolved
8468 -- properly, set the proper equality operator on the node. The
8469 -- current setting is the first one found during analysis, which
8470 -- is not necessarily the one to which the node has resolved.
8472 if Is_Overloaded (N) then
8478 Get_First_Interp (N, I, It);
8480 -- If the equality is user-defined, the type of the operands
8481 -- matches that of the formals. For a predefined operqtor,
8482 -- it is the scope that matters, given that the predefined
8483 -- equality has Any_Type formals. In either case the result
8484 -- type (most often Booleam) must match the context .The
8485 -- scope is either that of the type if there is a generated
8486 -- equality (when there is an equality for the component type)
8487 -- or else Standard otherwise.
8489 while Present (It.Typ) loop
8490 if Etype (It.Nam) = Typ
8492 (Etype (First_Entity (It.Nam)) = Etype (L)
8493 or else Scope (It.Nam) = Standard_Standard
8494 or else Scope (It.Nam) = Scope (T))
8496 Set_Entity (N, It.Nam);
8498 Set_Is_Overloaded (N, False);
8502 Get_Next_Interp (I, It);
8505 -- If expansion is active and this is an inherited operation,
8506 -- replace it with its ancestor. This must not be done during
8507 -- preanalysis because the type may not be frozen yet, as when
8508 -- the context is a precondition or postcondition.
8510 if Present (Alias (Entity (N))) and then Expander_Active then
8511 Set_Entity (N, Alias (Entity (N)));
8516 Check_Unset_Reference (L);
8517 Check_Unset_Reference (R);
8518 Generate_Operator_Reference (N, T);
8519 Check_Low_Bound_Tested (N);
8521 -- If this is an inequality, it may be the implicit inequality
8522 -- created for a user-defined operation, in which case the corres-
8523 -- ponding equality operation is not intrinsic, and the operation
8524 -- cannot be constant-folded. Else fold.
8526 if Nkind (N) = N_Op_Eq
8527 or else Comes_From_Source (Entity (N))
8528 or else Ekind (Entity (N)) = E_Operator
8529 or else Is_Intrinsic_Subprogram
8530 (Corresponding_Equality (Entity (N)))
8532 Analyze_Dimension (N);
8533 Eval_Relational_Op (N);
8535 elsif Nkind (N) = N_Op_Ne
8536 and then Is_Abstract_Subprogram (Entity (N))
8538 Error_Msg_NE ("cannot call abstract subprogram &!", N, Entity (N));
8541 -- Ada 2005: If one operand is an anonymous access type, convert the
8542 -- other operand to it, to ensure that the underlying types match in
8543 -- the back-end. Same for access_to_subprogram, and the conversion
8544 -- verifies that the types are subtype conformant.
8546 -- We apply the same conversion in the case one of the operands is a
8547 -- private subtype of the type of the other.
8549 -- Why the Expander_Active test here ???
8553 (Ekind_In (T, E_Anonymous_Access_Type,
8554 E_Anonymous_Access_Subprogram_Type)
8555 or else Is_Private_Type (T))
8557 if Etype (L) /= T then
8559 Make_Unchecked_Type_Conversion (Sloc (L),
8560 Subtype_Mark => New_Occurrence_Of (T, Sloc (L)),
8561 Expression => Relocate_Node (L)));
8562 Analyze_And_Resolve (L, T);
8565 if (Etype (R)) /= T then
8567 Make_Unchecked_Type_Conversion (Sloc (R),
8568 Subtype_Mark => New_Occurrence_Of (Etype (L), Sloc (R)),
8569 Expression => Relocate_Node (R)));
8570 Analyze_And_Resolve (R, T);
8574 end Resolve_Equality_Op;
8576 ----------------------------------
8577 -- Resolve_Explicit_Dereference --
8578 ----------------------------------
8580 procedure Resolve_Explicit_Dereference (N : Node_Id; Typ : Entity_Id) is
8581 Loc : constant Source_Ptr := Sloc (N);
8583 P : constant Node_Id := Prefix (N);
8586 -- The candidate prefix type, if overloaded
8592 Check_Fully_Declared_Prefix (Typ, P);
8595 -- A useful optimization: check whether the dereference denotes an
8596 -- element of a container, and if so rewrite it as a call to the
8597 -- corresponding Element function.
8599 -- Disabled for now, on advice of ARG. A more restricted form of the
8600 -- predicate might be acceptable ???
8602 -- if Is_Container_Element (N) then
8606 if Is_Overloaded (P) then
8608 -- Use the context type to select the prefix that has the correct
8609 -- designated type. Keep the first match, which will be the inner-
8612 Get_First_Interp (P, I, It);
8614 while Present (It.Typ) loop
8615 if Is_Access_Type (It.Typ)
8616 and then Covers (Typ, Designated_Type (It.Typ))
8622 -- Remove access types that do not match, but preserve access
8623 -- to subprogram interpretations, in case a further dereference
8624 -- is needed (see below).
8626 elsif Ekind (It.Typ) /= E_Access_Subprogram_Type then
8630 Get_Next_Interp (I, It);
8633 if Present (P_Typ) then
8635 Set_Etype (N, Designated_Type (P_Typ));
8638 -- If no interpretation covers the designated type of the prefix,
8639 -- this is the pathological case where not all implementations of
8640 -- the prefix allow the interpretation of the node as a call. Now
8641 -- that the expected type is known, Remove other interpretations
8642 -- from prefix, rewrite it as a call, and resolve again, so that
8643 -- the proper call node is generated.
8645 Get_First_Interp (P, I, It);
8646 while Present (It.Typ) loop
8647 if Ekind (It.Typ) /= E_Access_Subprogram_Type then
8651 Get_Next_Interp (I, It);
8655 Make_Function_Call (Loc,
8657 Make_Explicit_Dereference (Loc,
8659 Parameter_Associations => New_List);
8661 Save_Interps (N, New_N);
8663 Analyze_And_Resolve (N, Typ);
8667 -- If not overloaded, resolve P with its own type
8673 -- If the prefix might be null, add an access check
8675 if Is_Access_Type (Etype (P))
8676 and then not Can_Never_Be_Null (Etype (P))
8678 Apply_Access_Check (N);
8681 -- If the designated type is a packed unconstrained array type, and the
8682 -- explicit dereference is not in the context of an attribute reference,
8683 -- then we must compute and set the actual subtype, since it is needed
8684 -- by Gigi. The reason we exclude the attribute case is that this is
8685 -- handled fine by Gigi, and in fact we use such attributes to build the
8686 -- actual subtype. We also exclude generated code (which builds actual
8687 -- subtypes directly if they are needed).
8689 if Is_Array_Type (Etype (N))
8690 and then Is_Packed (Etype (N))
8691 and then not Is_Constrained (Etype (N))
8692 and then Nkind (Parent (N)) /= N_Attribute_Reference
8693 and then Comes_From_Source (N)
8695 Set_Etype (N, Get_Actual_Subtype (N));
8698 Analyze_Dimension (N);
8700 -- Note: No Eval processing is required for an explicit dereference,
8701 -- because such a name can never be static.
8703 end Resolve_Explicit_Dereference;
8705 -------------------------------------
8706 -- Resolve_Expression_With_Actions --
8707 -------------------------------------
8709 procedure Resolve_Expression_With_Actions (N : Node_Id; Typ : Entity_Id) is
8713 -- If N has no actions, and its expression has been constant folded,
8714 -- then rewrite N as just its expression. Note, we can't do this in
8715 -- the general case of Is_Empty_List (Actions (N)) as this would cause
8716 -- Expression (N) to be expanded again.
8718 if Is_Empty_List (Actions (N))
8719 and then Compile_Time_Known_Value (Expression (N))
8721 Rewrite (N, Expression (N));
8723 end Resolve_Expression_With_Actions;
8725 ----------------------------------
8726 -- Resolve_Generalized_Indexing --
8727 ----------------------------------
8729 procedure Resolve_Generalized_Indexing (N : Node_Id; Typ : Entity_Id) is
8730 Indexing : constant Node_Id := Generalized_Indexing (N);
8736 -- In ASIS mode, propagate the information about the indexes back to
8737 -- to the original indexing node. The generalized indexing is either
8738 -- a function call, or a dereference of one. The actuals include the
8739 -- prefix of the original node, which is the container expression.
8742 Resolve (Indexing, Typ);
8743 Set_Etype (N, Etype (Indexing));
8744 Set_Is_Overloaded (N, False);
8747 while Nkind_In (Call, N_Explicit_Dereference, N_Selected_Component)
8749 Call := Prefix (Call);
8752 if Nkind (Call) = N_Function_Call then
8753 Indexes := New_Copy_List (Parameter_Associations (Call));
8754 Pref := Remove_Head (Indexes);
8755 Set_Expressions (N, Indexes);
8757 -- If expression is to be reanalyzed, reset Generalized_Indexing
8758 -- to recreate call node, as is the case when the expression is
8759 -- part of an expression function.
8761 if In_Spec_Expression then
8762 Set_Generalized_Indexing (N, Empty);
8765 Set_Prefix (N, Pref);
8769 Rewrite (N, Indexing);
8772 end Resolve_Generalized_Indexing;
8774 ---------------------------
8775 -- Resolve_If_Expression --
8776 ---------------------------
8778 procedure Resolve_If_Expression (N : Node_Id; Typ : Entity_Id) is
8779 procedure Apply_Check (Expr : Node_Id);
8780 -- When a dependent expression is of a subtype different from
8781 -- the context subtype, then insert a qualification to ensure
8782 -- the generation of a constraint check. This was previously
8783 -- for scalar types. For array types apply a length check, given
8784 -- that the context in general allows sliding, while a qualified
8785 -- expression forces equality of bounds.
8791 procedure Apply_Check (Expr : Node_Id) is
8792 Expr_Typ : constant Entity_Id := Etype (Expr);
8793 Loc : constant Source_Ptr := Sloc (Expr);
8797 or else Is_Tagged_Type (Typ)
8798 or else Is_Access_Type (Typ)
8799 or else not Is_Constrained (Typ)
8800 or else Inside_A_Generic
8804 elsif Is_Array_Type (Typ) then
8805 Apply_Length_Check (Expr, Typ);
8809 Make_Qualified_Expression (Loc,
8810 Subtype_Mark => New_Occurrence_Of (Typ, Loc),
8811 Expression => Relocate_Node (Expr)));
8813 Analyze_And_Resolve (Expr, Typ);
8819 Condition : constant Node_Id := First (Expressions (N));
8820 Else_Expr : Node_Id;
8821 Then_Expr : Node_Id;
8823 -- Start of processing for Resolve_If_Expression
8826 -- Defend against malformed expressions
8828 if No (Condition) then
8832 Then_Expr := Next (Condition);
8834 if No (Then_Expr) then
8838 Else_Expr := Next (Then_Expr);
8840 Resolve (Condition, Any_Boolean);
8841 Resolve (Then_Expr, Typ);
8842 Apply_Check (Then_Expr);
8844 -- If ELSE expression present, just resolve using the determined type
8845 -- If type is universal, resolve to any member of the class.
8847 if Present (Else_Expr) then
8848 if Typ = Universal_Integer then
8849 Resolve (Else_Expr, Any_Integer);
8851 elsif Typ = Universal_Real then
8852 Resolve (Else_Expr, Any_Real);
8855 Resolve (Else_Expr, Typ);
8858 Apply_Check (Else_Expr);
8860 -- Apply RM 4.5.7 (17/3): whether the expression is statically or
8861 -- dynamically tagged must be known statically.
8863 if Is_Tagged_Type (Typ) and then not Is_Class_Wide_Type (Typ) then
8864 if Is_Dynamically_Tagged (Then_Expr) /=
8865 Is_Dynamically_Tagged (Else_Expr)
8867 Error_Msg_N ("all or none of the dependent expressions "
8868 & "can be dynamically tagged", N);
8872 -- If no ELSE expression is present, root type must be Standard.Boolean
8873 -- and we provide a Standard.True result converted to the appropriate
8874 -- Boolean type (in case it is a derived boolean type).
8876 elsif Root_Type (Typ) = Standard_Boolean then
8878 Convert_To (Typ, New_Occurrence_Of (Standard_True, Sloc (N)));
8879 Analyze_And_Resolve (Else_Expr, Typ);
8880 Append_To (Expressions (N), Else_Expr);
8883 Error_Msg_N ("can only omit ELSE expression in Boolean case", N);
8884 Append_To (Expressions (N), Error);
8889 if not Error_Posted (N) then
8890 Eval_If_Expression (N);
8893 Analyze_Dimension (N);
8894 end Resolve_If_Expression;
8896 -------------------------------
8897 -- Resolve_Indexed_Component --
8898 -------------------------------
8900 procedure Resolve_Indexed_Component (N : Node_Id; Typ : Entity_Id) is
8901 Name : constant Node_Id := Prefix (N);
8903 Array_Type : Entity_Id := Empty; -- to prevent junk warning
8907 if Present (Generalized_Indexing (N)) then
8908 Resolve_Generalized_Indexing (N, Typ);
8912 if Is_Overloaded (Name) then
8914 -- Use the context type to select the prefix that yields the correct
8920 I1 : Interp_Index := 0;
8921 P : constant Node_Id := Prefix (N);
8922 Found : Boolean := False;
8925 Get_First_Interp (P, I, It);
8926 while Present (It.Typ) loop
8927 if (Is_Array_Type (It.Typ)
8928 and then Covers (Typ, Component_Type (It.Typ)))
8929 or else (Is_Access_Type (It.Typ)
8930 and then Is_Array_Type (Designated_Type (It.Typ))
8934 Component_Type (Designated_Type (It.Typ))))
8937 It := Disambiguate (P, I1, I, Any_Type);
8939 if It = No_Interp then
8940 Error_Msg_N ("ambiguous prefix for indexing", N);
8946 Array_Type := It.Typ;
8952 Array_Type := It.Typ;
8957 Get_Next_Interp (I, It);
8962 Array_Type := Etype (Name);
8965 Resolve (Name, Array_Type);
8966 Array_Type := Get_Actual_Subtype_If_Available (Name);
8968 -- If prefix is access type, dereference to get real array type.
8969 -- Note: we do not apply an access check because the expander always
8970 -- introduces an explicit dereference, and the check will happen there.
8972 if Is_Access_Type (Array_Type) then
8973 Array_Type := Designated_Type (Array_Type);
8976 -- If name was overloaded, set component type correctly now
8977 -- If a misplaced call to an entry family (which has no index types)
8978 -- return. Error will be diagnosed from calling context.
8980 if Is_Array_Type (Array_Type) then
8981 Set_Etype (N, Component_Type (Array_Type));
8986 Index := First_Index (Array_Type);
8987 Expr := First (Expressions (N));
8989 -- The prefix may have resolved to a string literal, in which case its
8990 -- etype has a special representation. This is only possible currently
8991 -- if the prefix is a static concatenation, written in functional
8994 if Ekind (Array_Type) = E_String_Literal_Subtype then
8995 Resolve (Expr, Standard_Positive);
8998 while Present (Index) and Present (Expr) loop
8999 Resolve (Expr, Etype (Index));
9000 Check_Unset_Reference (Expr);
9002 if Is_Scalar_Type (Etype (Expr)) then
9003 Apply_Scalar_Range_Check (Expr, Etype (Index));
9005 Apply_Range_Check (Expr, Get_Actual_Subtype (Index));
9013 Analyze_Dimension (N);
9015 -- Do not generate the warning on suspicious index if we are analyzing
9016 -- package Ada.Tags; otherwise we will report the warning with the
9017 -- Prims_Ptr field of the dispatch table.
9019 if Scope (Etype (Prefix (N))) = Standard_Standard
9021 Is_RTU (Cunit_Entity (Get_Source_Unit (Etype (Prefix (N)))),
9024 Warn_On_Suspicious_Index (Name, First (Expressions (N)));
9025 Eval_Indexed_Component (N);
9028 -- If the array type is atomic, and the component is not atomic, then
9029 -- this is worth a warning, since we have a situation where the access
9030 -- to the component may cause extra read/writes of the atomic array
9031 -- object, or partial word accesses, which could be unexpected.
9033 if Nkind (N) = N_Indexed_Component
9034 and then Is_Atomic_Ref_With_Address (N)
9035 and then not (Has_Atomic_Components (Array_Type)
9036 or else (Is_Entity_Name (Prefix (N))
9037 and then Has_Atomic_Components
9038 (Entity (Prefix (N)))))
9039 and then not Is_Atomic (Component_Type (Array_Type))
9042 ("??access to non-atomic component of atomic array", Prefix (N));
9044 ("??\may cause unexpected accesses to atomic object", Prefix (N));
9046 end Resolve_Indexed_Component;
9048 -----------------------------
9049 -- Resolve_Integer_Literal --
9050 -----------------------------
9052 procedure Resolve_Integer_Literal (N : Node_Id; Typ : Entity_Id) is
9055 Eval_Integer_Literal (N);
9056 end Resolve_Integer_Literal;
9058 --------------------------------
9059 -- Resolve_Intrinsic_Operator --
9060 --------------------------------
9062 procedure Resolve_Intrinsic_Operator (N : Node_Id; Typ : Entity_Id) is
9063 Btyp : constant Entity_Id := Base_Type (Underlying_Type (Typ));
9068 function Convert_Operand (Opnd : Node_Id) return Node_Id;
9069 -- If the operand is a literal, it cannot be the expression in a
9070 -- conversion. Use a qualified expression instead.
9072 ---------------------
9073 -- Convert_Operand --
9074 ---------------------
9076 function Convert_Operand (Opnd : Node_Id) return Node_Id is
9077 Loc : constant Source_Ptr := Sloc (Opnd);
9081 if Nkind_In (Opnd, N_Integer_Literal, N_Real_Literal) then
9083 Make_Qualified_Expression (Loc,
9084 Subtype_Mark => New_Occurrence_Of (Btyp, Loc),
9085 Expression => Relocate_Node (Opnd));
9089 Res := Unchecked_Convert_To (Btyp, Opnd);
9093 end Convert_Operand;
9095 -- Start of processing for Resolve_Intrinsic_Operator
9098 -- We must preserve the original entity in a generic setting, so that
9099 -- the legality of the operation can be verified in an instance.
9101 if not Expander_Active then
9106 while Scope (Op) /= Standard_Standard loop
9108 pragma Assert (Present (Op));
9112 Set_Is_Overloaded (N, False);
9114 -- If the result or operand types are private, rewrite with unchecked
9115 -- conversions on the operands and the result, to expose the proper
9116 -- underlying numeric type.
9118 if Is_Private_Type (Typ)
9119 or else Is_Private_Type (Etype (Left_Opnd (N)))
9120 or else Is_Private_Type (Etype (Right_Opnd (N)))
9122 Arg1 := Convert_Operand (Left_Opnd (N));
9124 if Nkind (N) = N_Op_Expon then
9125 Arg2 := Unchecked_Convert_To (Standard_Integer, Right_Opnd (N));
9127 Arg2 := Convert_Operand (Right_Opnd (N));
9130 if Nkind (Arg1) = N_Type_Conversion then
9131 Save_Interps (Left_Opnd (N), Expression (Arg1));
9134 if Nkind (Arg2) = N_Type_Conversion then
9135 Save_Interps (Right_Opnd (N), Expression (Arg2));
9138 Set_Left_Opnd (N, Arg1);
9139 Set_Right_Opnd (N, Arg2);
9141 Set_Etype (N, Btyp);
9142 Rewrite (N, Unchecked_Convert_To (Typ, N));
9145 elsif Typ /= Etype (Left_Opnd (N))
9146 or else Typ /= Etype (Right_Opnd (N))
9148 -- Add explicit conversion where needed, and save interpretations in
9149 -- case operands are overloaded.
9151 Arg1 := Convert_To (Typ, Left_Opnd (N));
9152 Arg2 := Convert_To (Typ, Right_Opnd (N));
9154 if Nkind (Arg1) = N_Type_Conversion then
9155 Save_Interps (Left_Opnd (N), Expression (Arg1));
9157 Save_Interps (Left_Opnd (N), Arg1);
9160 if Nkind (Arg2) = N_Type_Conversion then
9161 Save_Interps (Right_Opnd (N), Expression (Arg2));
9163 Save_Interps (Right_Opnd (N), Arg2);
9166 Rewrite (Left_Opnd (N), Arg1);
9167 Rewrite (Right_Opnd (N), Arg2);
9170 Resolve_Arithmetic_Op (N, Typ);
9173 Resolve_Arithmetic_Op (N, Typ);
9175 end Resolve_Intrinsic_Operator;
9177 --------------------------------------
9178 -- Resolve_Intrinsic_Unary_Operator --
9179 --------------------------------------
9181 procedure Resolve_Intrinsic_Unary_Operator
9185 Btyp : constant Entity_Id := Base_Type (Underlying_Type (Typ));
9191 while Scope (Op) /= Standard_Standard loop
9193 pragma Assert (Present (Op));
9198 if Is_Private_Type (Typ) then
9199 Arg2 := Unchecked_Convert_To (Btyp, Right_Opnd (N));
9200 Save_Interps (Right_Opnd (N), Expression (Arg2));
9202 Set_Right_Opnd (N, Arg2);
9204 Set_Etype (N, Btyp);
9205 Rewrite (N, Unchecked_Convert_To (Typ, N));
9209 Resolve_Unary_Op (N, Typ);
9211 end Resolve_Intrinsic_Unary_Operator;
9213 ------------------------
9214 -- Resolve_Logical_Op --
9215 ------------------------
9217 procedure Resolve_Logical_Op (N : Node_Id; Typ : Entity_Id) is
9221 Check_No_Direct_Boolean_Operators (N);
9223 -- Predefined operations on scalar types yield the base type. On the
9224 -- other hand, logical operations on arrays yield the type of the
9225 -- arguments (and the context).
9227 if Is_Array_Type (Typ) then
9230 B_Typ := Base_Type (Typ);
9233 -- The following test is required because the operands of the operation
9234 -- may be literals, in which case the resulting type appears to be
9235 -- compatible with a signed integer type, when in fact it is compatible
9236 -- only with modular types. If the context itself is universal, the
9237 -- operation is illegal.
9239 if not Valid_Boolean_Arg (Typ) then
9240 Error_Msg_N ("invalid context for logical operation", N);
9241 Set_Etype (N, Any_Type);
9244 elsif Typ = Any_Modular then
9246 ("no modular type available in this context", N);
9247 Set_Etype (N, Any_Type);
9250 elsif Is_Modular_Integer_Type (Typ)
9251 and then Etype (Left_Opnd (N)) = Universal_Integer
9252 and then Etype (Right_Opnd (N)) = Universal_Integer
9254 Check_For_Visible_Operator (N, B_Typ);
9257 -- Replace AND by AND THEN, or OR by OR ELSE, if Short_Circuit_And_Or
9258 -- is active and the result type is standard Boolean (do not mess with
9259 -- ops that return a nonstandard Boolean type, because something strange
9262 -- Note: you might expect this replacement to be done during expansion,
9263 -- but that doesn't work, because when the pragma Short_Circuit_And_Or
9264 -- is used, no part of the right operand of an "and" or "or" operator
9265 -- should be executed if the left operand would short-circuit the
9266 -- evaluation of the corresponding "and then" or "or else". If we left
9267 -- the replacement to expansion time, then run-time checks associated
9268 -- with such operands would be evaluated unconditionally, due to being
9269 -- before the condition prior to the rewriting as short-circuit forms
9270 -- during expansion.
9272 if Short_Circuit_And_Or
9273 and then B_Typ = Standard_Boolean
9274 and then Nkind_In (N, N_Op_And, N_Op_Or)
9276 -- Mark the corresponding putative SCO operator as truly a logical
9277 -- (and short-circuit) operator.
9279 if Generate_SCO and then Comes_From_Source (N) then
9280 Set_SCO_Logical_Operator (N);
9283 if Nkind (N) = N_Op_And then
9285 Make_And_Then (Sloc (N),
9286 Left_Opnd => Relocate_Node (Left_Opnd (N)),
9287 Right_Opnd => Relocate_Node (Right_Opnd (N))));
9288 Analyze_And_Resolve (N, B_Typ);
9290 -- Case of OR changed to OR ELSE
9294 Make_Or_Else (Sloc (N),
9295 Left_Opnd => Relocate_Node (Left_Opnd (N)),
9296 Right_Opnd => Relocate_Node (Right_Opnd (N))));
9297 Analyze_And_Resolve (N, B_Typ);
9300 -- Return now, since analysis of the rewritten ops will take care of
9301 -- other reference bookkeeping and expression folding.
9306 Resolve (Left_Opnd (N), B_Typ);
9307 Resolve (Right_Opnd (N), B_Typ);
9309 Check_Unset_Reference (Left_Opnd (N));
9310 Check_Unset_Reference (Right_Opnd (N));
9312 Set_Etype (N, B_Typ);
9313 Generate_Operator_Reference (N, B_Typ);
9314 Eval_Logical_Op (N);
9316 -- In SPARK, logical operations AND, OR and XOR for arrays are defined
9317 -- only when both operands have same static lower and higher bounds. Of
9318 -- course the types have to match, so only check if operands are
9319 -- compatible and the node itself has no errors.
9321 if Is_Array_Type (B_Typ)
9322 and then Nkind (N) in N_Binary_Op
9325 Left_Typ : constant Node_Id := Etype (Left_Opnd (N));
9326 Right_Typ : constant Node_Id := Etype (Right_Opnd (N));
9329 -- Protect call to Matching_Static_Array_Bounds to avoid costly
9330 -- operation if not needed.
9332 if Restriction_Check_Required (SPARK_05)
9333 and then Base_Type (Left_Typ) = Base_Type (Right_Typ)
9334 and then Left_Typ /= Any_Composite -- or Left_Opnd in error
9335 and then Right_Typ /= Any_Composite -- or Right_Opnd in error
9336 and then not Matching_Static_Array_Bounds (Left_Typ, Right_Typ)
9338 Check_SPARK_05_Restriction
9339 ("array types should have matching static bounds", N);
9343 end Resolve_Logical_Op;
9345 ---------------------------
9346 -- Resolve_Membership_Op --
9347 ---------------------------
9349 -- The context can only be a boolean type, and does not determine the
9350 -- arguments. Arguments should be unambiguous, but the preference rule for
9351 -- universal types applies.
9353 procedure Resolve_Membership_Op (N : Node_Id; Typ : Entity_Id) is
9354 pragma Warnings (Off, Typ);
9356 L : constant Node_Id := Left_Opnd (N);
9357 R : constant Node_Id := Right_Opnd (N);
9360 procedure Resolve_Set_Membership;
9361 -- Analysis has determined a unique type for the left operand. Use it to
9362 -- resolve the disjuncts.
9364 ----------------------------
9365 -- Resolve_Set_Membership --
9366 ----------------------------
9368 procedure Resolve_Set_Membership is
9373 -- If the left operand is overloaded, find type compatible with not
9374 -- overloaded alternative of the right operand.
9376 if Is_Overloaded (L) then
9378 Alt := First (Alternatives (N));
9379 while Present (Alt) loop
9380 if not Is_Overloaded (Alt) then
9381 Ltyp := Intersect_Types (L, Alt);
9388 -- Unclear how to resolve expression if all alternatives are also
9392 Error_Msg_N ("ambiguous expression", N);
9401 Alt := First (Alternatives (N));
9402 while Present (Alt) loop
9404 -- Alternative is an expression, a range
9405 -- or a subtype mark.
9407 if not Is_Entity_Name (Alt)
9408 or else not Is_Type (Entity (Alt))
9410 Resolve (Alt, Ltyp);
9416 -- Check for duplicates for discrete case
9418 if Is_Discrete_Type (Ltyp) then
9425 Alts : array (0 .. List_Length (Alternatives (N))) of Ent;
9429 -- Loop checking duplicates. This is quadratic, but giant sets
9430 -- are unlikely in this context so it's a reasonable choice.
9433 Alt := First (Alternatives (N));
9434 while Present (Alt) loop
9435 if Is_OK_Static_Expression (Alt)
9436 and then (Nkind_In (Alt, N_Integer_Literal,
9437 N_Character_Literal)
9438 or else Nkind (Alt) in N_Has_Entity)
9441 Alts (Nalts) := (Alt, Expr_Value (Alt));
9443 for J in 1 .. Nalts - 1 loop
9444 if Alts (J).Val = Alts (Nalts).Val then
9445 Error_Msg_Sloc := Sloc (Alts (J).Alt);
9446 Error_Msg_N ("duplicate of value given#??", Alt);
9456 -- RM 4.5.2 (28.1/3) specifies that for types other than records or
9457 -- limited types, evaluation of a membership test uses the predefined
9458 -- equality for the type. This may be confusing to users, and the
9459 -- following warning appears useful for the most common case.
9461 if Is_Scalar_Type (Ltyp)
9462 and then Present (Get_User_Defined_Eq (Ltyp))
9465 ("membership test on& uses predefined equality?", N, Ltyp);
9467 ("\even if user-defined equality exists (RM 4.5.2 (28.1/3)?", N);
9469 end Resolve_Set_Membership;
9471 -- Start of processing for Resolve_Membership_Op
9474 if L = Error or else R = Error then
9478 if Present (Alternatives (N)) then
9479 Resolve_Set_Membership;
9482 elsif not Is_Overloaded (R)
9484 (Etype (R) = Universal_Integer
9486 Etype (R) = Universal_Real)
9487 and then Is_Overloaded (L)
9491 -- Ada 2005 (AI-251): Support the following case:
9493 -- type I is interface;
9494 -- type T is tagged ...
9496 -- function Test (O : I'Class) is
9498 -- return O in T'Class.
9501 -- In this case we have nothing else to do. The membership test will be
9502 -- done at run time.
9504 elsif Ada_Version >= Ada_2005
9505 and then Is_Class_Wide_Type (Etype (L))
9506 and then Is_Interface (Etype (L))
9507 and then not Is_Interface (Etype (R))
9511 T := Intersect_Types (L, R);
9514 -- If mixed-mode operations are present and operands are all literal,
9515 -- the only interpretation involves Duration, which is probably not
9516 -- the intention of the programmer.
9518 if T = Any_Fixed then
9519 T := Unique_Fixed_Point_Type (N);
9521 if T = Any_Type then
9527 Check_Unset_Reference (L);
9529 if Nkind (R) = N_Range
9530 and then not Is_Scalar_Type (T)
9532 Error_Msg_N ("scalar type required for range", R);
9535 if Is_Entity_Name (R) then
9536 Freeze_Expression (R);
9539 Check_Unset_Reference (R);
9542 -- Here after resolving membership operation
9546 Eval_Membership_Op (N);
9547 end Resolve_Membership_Op;
9553 procedure Resolve_Null (N : Node_Id; Typ : Entity_Id) is
9554 Loc : constant Source_Ptr := Sloc (N);
9557 -- Handle restriction against anonymous null access values This
9558 -- restriction can be turned off using -gnatdj.
9560 -- Ada 2005 (AI-231): Remove restriction
9562 if Ada_Version < Ada_2005
9563 and then not Debug_Flag_J
9564 and then Ekind (Typ) = E_Anonymous_Access_Type
9565 and then Comes_From_Source (N)
9567 -- In the common case of a call which uses an explicitly null value
9568 -- for an access parameter, give specialized error message.
9570 if Nkind (Parent (N)) in N_Subprogram_Call then
9572 ("null is not allowed as argument for an access parameter", N);
9574 -- Standard message for all other cases (are there any?)
9578 ("null cannot be of an anonymous access type", N);
9582 -- Ada 2005 (AI-231): Generate the null-excluding check in case of
9583 -- assignment to a null-excluding object.
9585 if Ada_Version >= Ada_2005
9586 and then Can_Never_Be_Null (Typ)
9587 and then Nkind (Parent (N)) = N_Assignment_Statement
9589 if Inside_Init_Proc then
9591 -- Decide whether to generate an if_statement around our
9592 -- null-excluding check to avoid them on certain internal object
9593 -- declarations by looking at the type the current Init_Proc
9597 -- if T1b_skip_null_excluding_check then
9598 -- [constraint_error "access check failed"]
9601 if Needs_Conditional_Null_Excluding_Check
9602 (Etype (First_Formal (Enclosing_Init_Proc)))
9605 Make_If_Statement (Loc,
9607 Make_Identifier (Loc,
9609 (Chars (Typ), "_skip_null_excluding_check")),
9612 Make_Raise_Constraint_Error (Loc,
9613 Reason => CE_Access_Check_Failed))));
9615 -- Otherwise, simply create the check
9619 Make_Raise_Constraint_Error (Loc,
9620 Reason => CE_Access_Check_Failed));
9624 (Compile_Time_Constraint_Error (N,
9625 "(Ada 2005) null not allowed in null-excluding objects??"),
9626 Make_Raise_Constraint_Error (Loc,
9627 Reason => CE_Access_Check_Failed));
9631 -- In a distributed context, null for a remote access to subprogram may
9632 -- need to be replaced with a special record aggregate. In this case,
9633 -- return after having done the transformation.
9635 if (Ekind (Typ) = E_Record_Type
9636 or else Is_Remote_Access_To_Subprogram_Type (Typ))
9637 and then Remote_AST_Null_Value (N, Typ)
9642 -- The null literal takes its type from the context
9647 -----------------------
9648 -- Resolve_Op_Concat --
9649 -----------------------
9651 procedure Resolve_Op_Concat (N : Node_Id; Typ : Entity_Id) is
9653 -- We wish to avoid deep recursion, because concatenations are often
9654 -- deeply nested, as in A&B&...&Z. Therefore, we walk down the left
9655 -- operands nonrecursively until we find something that is not a simple
9656 -- concatenation (A in this case). We resolve that, and then walk back
9657 -- up the tree following Parent pointers, calling Resolve_Op_Concat_Rest
9658 -- to do the rest of the work at each level. The Parent pointers allow
9659 -- us to avoid recursion, and thus avoid running out of memory. See also
9660 -- Sem_Ch4.Analyze_Concatenation, where a similar approach is used.
9666 -- The following code is equivalent to:
9668 -- Resolve_Op_Concat_First (NN, Typ);
9669 -- Resolve_Op_Concat_Arg (N, ...);
9670 -- Resolve_Op_Concat_Rest (N, Typ);
9672 -- where the Resolve_Op_Concat_Arg call recurses back here if the left
9673 -- operand is a concatenation.
9675 -- Walk down left operands
9678 Resolve_Op_Concat_First (NN, Typ);
9679 Op1 := Left_Opnd (NN);
9680 exit when not (Nkind (Op1) = N_Op_Concat
9681 and then not Is_Array_Type (Component_Type (Typ))
9682 and then Entity (Op1) = Entity (NN));
9686 -- Now (given the above example) NN is A&B and Op1 is A
9688 -- First resolve Op1 ...
9690 Resolve_Op_Concat_Arg (NN, Op1, Typ, Is_Component_Left_Opnd (NN));
9692 -- ... then walk NN back up until we reach N (where we started), calling
9693 -- Resolve_Op_Concat_Rest along the way.
9696 Resolve_Op_Concat_Rest (NN, Typ);
9701 if Base_Type (Etype (N)) /= Standard_String then
9702 Check_SPARK_05_Restriction
9703 ("result of concatenation should have type String", N);
9705 end Resolve_Op_Concat;
9707 ---------------------------
9708 -- Resolve_Op_Concat_Arg --
9709 ---------------------------
9711 procedure Resolve_Op_Concat_Arg
9717 Btyp : constant Entity_Id := Base_Type (Typ);
9718 Ctyp : constant Entity_Id := Component_Type (Typ);
9723 or else (not Is_Overloaded (Arg)
9724 and then Etype (Arg) /= Any_Composite
9725 and then Covers (Ctyp, Etype (Arg)))
9727 Resolve (Arg, Ctyp);
9729 Resolve (Arg, Btyp);
9732 -- If both Array & Array and Array & Component are visible, there is a
9733 -- potential ambiguity that must be reported.
9735 elsif Has_Compatible_Type (Arg, Ctyp) then
9736 if Nkind (Arg) = N_Aggregate
9737 and then Is_Composite_Type (Ctyp)
9739 if Is_Private_Type (Ctyp) then
9740 Resolve (Arg, Btyp);
9742 -- If the operation is user-defined and not overloaded use its
9743 -- profile. The operation may be a renaming, in which case it has
9744 -- been rewritten, and we want the original profile.
9746 elsif not Is_Overloaded (N)
9747 and then Comes_From_Source (Entity (Original_Node (N)))
9748 and then Ekind (Entity (Original_Node (N))) = E_Function
9752 (Next_Formal (First_Formal (Entity (Original_Node (N))))));
9755 -- Otherwise an aggregate may match both the array type and the
9759 Error_Msg_N ("ambiguous aggregate must be qualified", Arg);
9760 Set_Etype (Arg, Any_Type);
9764 if Is_Overloaded (Arg)
9765 and then Has_Compatible_Type (Arg, Typ)
9766 and then Etype (Arg) /= Any_Type
9774 Get_First_Interp (Arg, I, It);
9776 Get_Next_Interp (I, It);
9778 -- Special-case the error message when the overloading is
9779 -- caused by a function that yields an array and can be
9780 -- called without parameters.
9782 if It.Nam = Func then
9783 Error_Msg_Sloc := Sloc (Func);
9784 Error_Msg_N ("ambiguous call to function#", Arg);
9786 ("\\interpretation as call yields&", Arg, Typ);
9788 ("\\interpretation as indexing of call yields&",
9789 Arg, Component_Type (Typ));
9792 Error_Msg_N ("ambiguous operand for concatenation!", Arg);
9794 Get_First_Interp (Arg, I, It);
9795 while Present (It.Nam) loop
9796 Error_Msg_Sloc := Sloc (It.Nam);
9798 if Base_Type (It.Typ) = Btyp
9800 Base_Type (It.Typ) = Base_Type (Ctyp)
9802 Error_Msg_N -- CODEFIX
9803 ("\\possible interpretation#", Arg);
9806 Get_Next_Interp (I, It);
9812 Resolve (Arg, Component_Type (Typ));
9814 if Nkind (Arg) = N_String_Literal then
9815 Set_Etype (Arg, Component_Type (Typ));
9818 if Arg = Left_Opnd (N) then
9819 Set_Is_Component_Left_Opnd (N);
9821 Set_Is_Component_Right_Opnd (N);
9826 Resolve (Arg, Btyp);
9829 -- Concatenation is restricted in SPARK: each operand must be either a
9830 -- string literal, the name of a string constant, a static character or
9831 -- string expression, or another concatenation. Arg cannot be a
9832 -- concatenation here as callers of Resolve_Op_Concat_Arg call it
9833 -- separately on each final operand, past concatenation operations.
9835 if Is_Character_Type (Etype (Arg)) then
9836 if not Is_OK_Static_Expression (Arg) then
9837 Check_SPARK_05_Restriction
9838 ("character operand for concatenation should be static", Arg);
9841 elsif Is_String_Type (Etype (Arg)) then
9842 if not (Nkind_In (Arg, N_Identifier, N_Expanded_Name)
9843 and then Is_Constant_Object (Entity (Arg)))
9844 and then not Is_OK_Static_Expression (Arg)
9846 Check_SPARK_05_Restriction
9847 ("string operand for concatenation should be static", Arg);
9850 -- Do not issue error on an operand that is neither a character nor a
9851 -- string, as the error is issued in Resolve_Op_Concat.
9857 Check_Unset_Reference (Arg);
9858 end Resolve_Op_Concat_Arg;
9860 -----------------------------
9861 -- Resolve_Op_Concat_First --
9862 -----------------------------
9864 procedure Resolve_Op_Concat_First (N : Node_Id; Typ : Entity_Id) is
9865 Btyp : constant Entity_Id := Base_Type (Typ);
9866 Op1 : constant Node_Id := Left_Opnd (N);
9867 Op2 : constant Node_Id := Right_Opnd (N);
9870 -- The parser folds an enormous sequence of concatenations of string
9871 -- literals into "" & "...", where the Is_Folded_In_Parser flag is set
9872 -- in the right operand. If the expression resolves to a predefined "&"
9873 -- operator, all is well. Otherwise, the parser's folding is wrong, so
9874 -- we give an error. See P_Simple_Expression in Par.Ch4.
9876 if Nkind (Op2) = N_String_Literal
9877 and then Is_Folded_In_Parser (Op2)
9878 and then Ekind (Entity (N)) = E_Function
9880 pragma Assert (Nkind (Op1) = N_String_Literal -- should be ""
9881 and then String_Length (Strval (Op1)) = 0);
9882 Error_Msg_N ("too many user-defined concatenations", N);
9886 Set_Etype (N, Btyp);
9888 if Is_Limited_Composite (Btyp) then
9889 Error_Msg_N ("concatenation not available for limited array", N);
9890 Explain_Limited_Type (Btyp, N);
9892 end Resolve_Op_Concat_First;
9894 ----------------------------
9895 -- Resolve_Op_Concat_Rest --
9896 ----------------------------
9898 procedure Resolve_Op_Concat_Rest (N : Node_Id; Typ : Entity_Id) is
9899 Op1 : constant Node_Id := Left_Opnd (N);
9900 Op2 : constant Node_Id := Right_Opnd (N);
9903 Resolve_Op_Concat_Arg (N, Op2, Typ, Is_Component_Right_Opnd (N));
9905 Generate_Operator_Reference (N, Typ);
9907 if Is_String_Type (Typ) then
9908 Eval_Concatenation (N);
9911 -- If this is not a static concatenation, but the result is a string
9912 -- type (and not an array of strings) ensure that static string operands
9913 -- have their subtypes properly constructed.
9915 if Nkind (N) /= N_String_Literal
9916 and then Is_Character_Type (Component_Type (Typ))
9918 Set_String_Literal_Subtype (Op1, Typ);
9919 Set_String_Literal_Subtype (Op2, Typ);
9921 end Resolve_Op_Concat_Rest;
9923 ----------------------
9924 -- Resolve_Op_Expon --
9925 ----------------------
9927 procedure Resolve_Op_Expon (N : Node_Id; Typ : Entity_Id) is
9928 B_Typ : constant Entity_Id := Base_Type (Typ);
9931 -- Catch attempts to do fixed-point exponentiation with universal
9932 -- operands, which is a case where the illegality is not caught during
9933 -- normal operator analysis. This is not done in preanalysis mode
9934 -- since the tree is not fully decorated during preanalysis.
9936 if Full_Analysis then
9937 if Is_Fixed_Point_Type (Typ) and then Comes_From_Source (N) then
9938 Error_Msg_N ("exponentiation not available for fixed point", N);
9941 elsif Nkind (Parent (N)) in N_Op
9942 and then Present (Etype (Parent (N)))
9943 and then Is_Fixed_Point_Type (Etype (Parent (N)))
9944 and then Etype (N) = Universal_Real
9945 and then Comes_From_Source (N)
9947 Error_Msg_N ("exponentiation not available for fixed point", N);
9952 if Comes_From_Source (N)
9953 and then Ekind (Entity (N)) = E_Function
9954 and then Is_Imported (Entity (N))
9955 and then Is_Intrinsic_Subprogram (Entity (N))
9957 Resolve_Intrinsic_Operator (N, Typ);
9961 if Etype (Left_Opnd (N)) = Universal_Integer
9962 or else Etype (Left_Opnd (N)) = Universal_Real
9964 Check_For_Visible_Operator (N, B_Typ);
9967 -- We do the resolution using the base type, because intermediate values
9968 -- in expressions are always of the base type, not a subtype of it.
9970 Resolve (Left_Opnd (N), B_Typ);
9971 Resolve (Right_Opnd (N), Standard_Integer);
9973 -- For integer types, right argument must be in Natural range
9975 if Is_Integer_Type (Typ) then
9976 Apply_Scalar_Range_Check (Right_Opnd (N), Standard_Natural);
9979 Check_Unset_Reference (Left_Opnd (N));
9980 Check_Unset_Reference (Right_Opnd (N));
9982 Set_Etype (N, B_Typ);
9983 Generate_Operator_Reference (N, B_Typ);
9985 Analyze_Dimension (N);
9987 if Ada_Version >= Ada_2012 and then Has_Dimension_System (B_Typ) then
9988 -- Evaluate the exponentiation operator for dimensioned type
9990 Eval_Op_Expon_For_Dimensioned_Type (N, B_Typ);
9995 -- Set overflow checking bit. Much cleverer code needed here eventually
9996 -- and perhaps the Resolve routines should be separated for the various
9997 -- arithmetic operations, since they will need different processing. ???
9999 if Nkind (N) in N_Op then
10000 if not Overflow_Checks_Suppressed (Etype (N)) then
10001 Enable_Overflow_Check (N);
10004 end Resolve_Op_Expon;
10006 --------------------
10007 -- Resolve_Op_Not --
10008 --------------------
10010 procedure Resolve_Op_Not (N : Node_Id; Typ : Entity_Id) is
10013 function Parent_Is_Boolean return Boolean;
10014 -- This function determines if the parent node is a boolean operator or
10015 -- operation (comparison op, membership test, or short circuit form) and
10016 -- the not in question is the left operand of this operation. Note that
10017 -- if the not is in parens, then false is returned.
10019 -----------------------
10020 -- Parent_Is_Boolean --
10021 -----------------------
10023 function Parent_Is_Boolean return Boolean is
10025 if Paren_Count (N) /= 0 then
10029 case Nkind (Parent (N)) is
10044 return Left_Opnd (Parent (N)) = N;
10050 end Parent_Is_Boolean;
10052 -- Start of processing for Resolve_Op_Not
10055 -- Predefined operations on scalar types yield the base type. On the
10056 -- other hand, logical operations on arrays yield the type of the
10057 -- arguments (and the context).
10059 if Is_Array_Type (Typ) then
10062 B_Typ := Base_Type (Typ);
10065 -- Straightforward case of incorrect arguments
10067 if not Valid_Boolean_Arg (Typ) then
10068 Error_Msg_N ("invalid operand type for operator&", N);
10069 Set_Etype (N, Any_Type);
10072 -- Special case of probable missing parens
10074 elsif Typ = Universal_Integer or else Typ = Any_Modular then
10075 if Parent_Is_Boolean then
10077 ("operand of not must be enclosed in parentheses",
10081 ("no modular type available in this context", N);
10084 Set_Etype (N, Any_Type);
10087 -- OK resolution of NOT
10090 -- Warn if non-boolean types involved. This is a case like not a < b
10091 -- where a and b are modular, where we will get (not a) < b and most
10092 -- likely not (a < b) was intended.
10094 if Warn_On_Questionable_Missing_Parens
10095 and then not Is_Boolean_Type (Typ)
10096 and then Parent_Is_Boolean
10098 Error_Msg_N ("?q?not expression should be parenthesized here!", N);
10101 -- Warn on double negation if checking redundant constructs
10103 if Warn_On_Redundant_Constructs
10104 and then Comes_From_Source (N)
10105 and then Comes_From_Source (Right_Opnd (N))
10106 and then Root_Type (Typ) = Standard_Boolean
10107 and then Nkind (Right_Opnd (N)) = N_Op_Not
10109 Error_Msg_N ("redundant double negation?r?", N);
10112 -- Complete resolution and evaluation of NOT
10113 -- If argument is an equality and expected type is boolean, that
10114 -- expected type has no effect on resolution, and there are
10115 -- special rules for resolution of Eq, Neq in the presence of
10116 -- overloaded operands, so we directly call its resolution routines.
10119 Opnd : constant Node_Id := Right_Opnd (N);
10123 if B_Typ = Standard_Boolean
10124 and then Nkind_In (Opnd, N_Op_Eq, N_Op_Ne)
10125 and then Is_Overloaded (Opnd)
10127 Resolve_Equality_Op (Opnd, B_Typ);
10128 Op_Id := Entity (Opnd);
10130 if Ekind (Op_Id) = E_Function
10131 and then not Is_Intrinsic_Subprogram (Op_Id)
10133 Rewrite_Operator_As_Call (Opnd, Op_Id);
10136 if not Inside_A_Generic or else Is_Entity_Name (Opnd) then
10137 Freeze_Expression (Opnd);
10143 Resolve (Opnd, B_Typ);
10146 Check_Unset_Reference (Opnd);
10149 Set_Etype (N, B_Typ);
10150 Generate_Operator_Reference (N, B_Typ);
10153 end Resolve_Op_Not;
10155 -----------------------------
10156 -- Resolve_Operator_Symbol --
10157 -----------------------------
10159 -- Nothing to be done, all resolved already
10161 procedure Resolve_Operator_Symbol (N : Node_Id; Typ : Entity_Id) is
10162 pragma Warnings (Off, N);
10163 pragma Warnings (Off, Typ);
10167 end Resolve_Operator_Symbol;
10169 ----------------------------------
10170 -- Resolve_Qualified_Expression --
10171 ----------------------------------
10173 procedure Resolve_Qualified_Expression (N : Node_Id; Typ : Entity_Id) is
10174 pragma Warnings (Off, Typ);
10176 Target_Typ : constant Entity_Id := Entity (Subtype_Mark (N));
10177 Expr : constant Node_Id := Expression (N);
10180 Resolve (Expr, Target_Typ);
10182 -- Protect call to Matching_Static_Array_Bounds to avoid costly
10183 -- operation if not needed.
10185 if Restriction_Check_Required (SPARK_05)
10186 and then Is_Array_Type (Target_Typ)
10187 and then Is_Array_Type (Etype (Expr))
10188 and then Etype (Expr) /= Any_Composite -- or else Expr in error
10189 and then not Matching_Static_Array_Bounds (Target_Typ, Etype (Expr))
10191 Check_SPARK_05_Restriction
10192 ("array types should have matching static bounds", N);
10195 -- A qualified expression requires an exact match of the type, class-
10196 -- wide matching is not allowed. However, if the qualifying type is
10197 -- specific and the expression has a class-wide type, it may still be
10198 -- okay, since it can be the result of the expansion of a call to a
10199 -- dispatching function, so we also have to check class-wideness of the
10200 -- type of the expression's original node.
10202 if (Is_Class_Wide_Type (Target_Typ)
10204 (Is_Class_Wide_Type (Etype (Expr))
10205 and then Is_Class_Wide_Type (Etype (Original_Node (Expr)))))
10206 and then Base_Type (Etype (Expr)) /= Base_Type (Target_Typ)
10208 Wrong_Type (Expr, Target_Typ);
10211 -- If the target type is unconstrained, then we reset the type of the
10212 -- result from the type of the expression. For other cases, the actual
10213 -- subtype of the expression is the target type.
10215 if Is_Composite_Type (Target_Typ)
10216 and then not Is_Constrained (Target_Typ)
10218 Set_Etype (N, Etype (Expr));
10221 Analyze_Dimension (N);
10222 Eval_Qualified_Expression (N);
10224 -- If we still have a qualified expression after the static evaluation,
10225 -- then apply a scalar range check if needed. The reason that we do this
10226 -- after the Eval call is that otherwise, the application of the range
10227 -- check may convert an illegal static expression and result in warning
10228 -- rather than giving an error (e.g Integer'(Integer'Last + 1)).
10230 if Nkind (N) = N_Qualified_Expression and then Is_Scalar_Type (Typ) then
10231 Apply_Scalar_Range_Check (Expr, Typ);
10234 -- Finally, check whether a predicate applies to the target type. This
10235 -- comes from AI12-0100. As for type conversions, check the enclosing
10236 -- context to prevent an infinite expansion.
10238 if Has_Predicates (Target_Typ) then
10239 if Nkind (Parent (N)) = N_Function_Call
10240 and then Present (Name (Parent (N)))
10241 and then (Is_Predicate_Function (Entity (Name (Parent (N))))
10243 Is_Predicate_Function_M (Entity (Name (Parent (N)))))
10247 -- In the case of a qualified expression in an allocator, the check
10248 -- is applied when expanding the allocator, so avoid redundant check.
10250 elsif Nkind (N) = N_Qualified_Expression
10251 and then Nkind (Parent (N)) /= N_Allocator
10253 Apply_Predicate_Check (N, Target_Typ);
10256 end Resolve_Qualified_Expression;
10258 ------------------------------
10259 -- Resolve_Raise_Expression --
10260 ------------------------------
10262 procedure Resolve_Raise_Expression (N : Node_Id; Typ : Entity_Id) is
10264 if Typ = Raise_Type then
10265 Error_Msg_N ("cannot find unique type for raise expression", N);
10266 Set_Etype (N, Any_Type);
10268 Set_Etype (N, Typ);
10270 end Resolve_Raise_Expression;
10272 -------------------
10273 -- Resolve_Range --
10274 -------------------
10276 procedure Resolve_Range (N : Node_Id; Typ : Entity_Id) is
10277 L : constant Node_Id := Low_Bound (N);
10278 H : constant Node_Id := High_Bound (N);
10280 function First_Last_Ref return Boolean;
10281 -- Returns True if N is of the form X'First .. X'Last where X is the
10282 -- same entity for both attributes.
10284 --------------------
10285 -- First_Last_Ref --
10286 --------------------
10288 function First_Last_Ref return Boolean is
10289 Lorig : constant Node_Id := Original_Node (L);
10290 Horig : constant Node_Id := Original_Node (H);
10293 if Nkind (Lorig) = N_Attribute_Reference
10294 and then Nkind (Horig) = N_Attribute_Reference
10295 and then Attribute_Name (Lorig) = Name_First
10296 and then Attribute_Name (Horig) = Name_Last
10299 PL : constant Node_Id := Prefix (Lorig);
10300 PH : constant Node_Id := Prefix (Horig);
10302 if Is_Entity_Name (PL)
10303 and then Is_Entity_Name (PH)
10304 and then Entity (PL) = Entity (PH)
10312 end First_Last_Ref;
10314 -- Start of processing for Resolve_Range
10317 Set_Etype (N, Typ);
10319 -- The lower bound should be in Typ. The higher bound can be in Typ's
10320 -- base type if the range is null. It may still be invalid if it is
10321 -- higher than the lower bound. This is checked later in the context in
10322 -- which the range appears.
10325 Resolve (H, Base_Type (Typ));
10327 -- Reanalyze the lower bound after both bounds have been analyzed, so
10328 -- that the range is known to be static or not by now. This may trigger
10329 -- more compile-time evaluation, which is useful for static analysis
10330 -- with GNATprove. This is not needed for compilation or static analysis
10331 -- with CodePeer, as full expansion does that evaluation then.
10333 if GNATprove_Mode then
10334 Set_Analyzed (L, False);
10338 -- Check for inappropriate range on unordered enumeration type
10340 if Bad_Unordered_Enumeration_Reference (N, Typ)
10342 -- Exclude X'First .. X'Last if X is the same entity for both
10344 and then not First_Last_Ref
10346 Error_Msg_Sloc := Sloc (Typ);
10348 ("subrange of unordered enumeration type& declared#?U?", N, Typ);
10351 Check_Unset_Reference (L);
10352 Check_Unset_Reference (H);
10354 -- We have to check the bounds for being within the base range as
10355 -- required for a non-static context. Normally this is automatic and
10356 -- done as part of evaluating expressions, but the N_Range node is an
10357 -- exception, since in GNAT we consider this node to be a subexpression,
10358 -- even though in Ada it is not. The circuit in Sem_Eval could check for
10359 -- this, but that would put the test on the main evaluation path for
10362 Check_Non_Static_Context (L);
10363 Check_Non_Static_Context (H);
10365 -- Check for an ambiguous range over character literals. This will
10366 -- happen with a membership test involving only literals.
10368 if Typ = Any_Character then
10369 Ambiguous_Character (L);
10370 Set_Etype (N, Any_Type);
10374 -- If bounds are static, constant-fold them, so size computations are
10375 -- identical between front-end and back-end. Do not perform this
10376 -- transformation while analyzing generic units, as type information
10377 -- would be lost when reanalyzing the constant node in the instance.
10379 if Is_Discrete_Type (Typ) and then Expander_Active then
10380 if Is_OK_Static_Expression (L) then
10381 Fold_Uint (L, Expr_Value (L), Is_OK_Static_Expression (L));
10384 if Is_OK_Static_Expression (H) then
10385 Fold_Uint (H, Expr_Value (H), Is_OK_Static_Expression (H));
10390 --------------------------
10391 -- Resolve_Real_Literal --
10392 --------------------------
10394 procedure Resolve_Real_Literal (N : Node_Id; Typ : Entity_Id) is
10395 Actual_Typ : constant Entity_Id := Etype (N);
10398 -- Special processing for fixed-point literals to make sure that the
10399 -- value is an exact multiple of small where this is required. We skip
10400 -- this for the universal real case, and also for generic types.
10402 if Is_Fixed_Point_Type (Typ)
10403 and then Typ /= Universal_Fixed
10404 and then Typ /= Any_Fixed
10405 and then not Is_Generic_Type (Typ)
10408 Val : constant Ureal := Realval (N);
10409 Cintr : constant Ureal := Val / Small_Value (Typ);
10410 Cint : constant Uint := UR_Trunc (Cintr);
10411 Den : constant Uint := Norm_Den (Cintr);
10415 -- Case of literal is not an exact multiple of the Small
10419 -- For a source program literal for a decimal fixed-point type,
10420 -- this is statically illegal (RM 4.9(36)).
10422 if Is_Decimal_Fixed_Point_Type (Typ)
10423 and then Actual_Typ = Universal_Real
10424 and then Comes_From_Source (N)
10426 Error_Msg_N ("value has extraneous low order digits", N);
10429 -- Generate a warning if literal from source
10431 if Is_OK_Static_Expression (N)
10432 and then Warn_On_Bad_Fixed_Value
10435 ("?b?static fixed-point value is not a multiple of Small!",
10439 -- Replace literal by a value that is the exact representation
10440 -- of a value of the type, i.e. a multiple of the small value,
10441 -- by truncation, since Machine_Rounds is false for all GNAT
10442 -- fixed-point types (RM 4.9(38)).
10444 Stat := Is_OK_Static_Expression (N);
10446 Make_Real_Literal (Sloc (N),
10447 Realval => Small_Value (Typ) * Cint));
10449 Set_Is_Static_Expression (N, Stat);
10452 -- In all cases, set the corresponding integer field
10454 Set_Corresponding_Integer_Value (N, Cint);
10458 -- Now replace the actual type by the expected type as usual
10460 Set_Etype (N, Typ);
10461 Eval_Real_Literal (N);
10462 end Resolve_Real_Literal;
10464 -----------------------
10465 -- Resolve_Reference --
10466 -----------------------
10468 procedure Resolve_Reference (N : Node_Id; Typ : Entity_Id) is
10469 P : constant Node_Id := Prefix (N);
10472 -- Replace general access with specific type
10474 if Ekind (Etype (N)) = E_Allocator_Type then
10475 Set_Etype (N, Base_Type (Typ));
10478 Resolve (P, Designated_Type (Etype (N)));
10480 -- If we are taking the reference of a volatile entity, then treat it as
10481 -- a potential modification of this entity. This is too conservative,
10482 -- but necessary because remove side effects can cause transformations
10483 -- of normal assignments into reference sequences that otherwise fail to
10484 -- notice the modification.
10486 if Is_Entity_Name (P) and then Treat_As_Volatile (Entity (P)) then
10487 Note_Possible_Modification (P, Sure => False);
10489 end Resolve_Reference;
10491 --------------------------------
10492 -- Resolve_Selected_Component --
10493 --------------------------------
10495 procedure Resolve_Selected_Component (N : Node_Id; Typ : Entity_Id) is
10497 Comp1 : Entity_Id := Empty; -- prevent junk warning
10498 P : constant Node_Id := Prefix (N);
10499 S : constant Node_Id := Selector_Name (N);
10500 T : Entity_Id := Etype (P);
10502 I1 : Interp_Index := 0; -- prevent junk warning
10507 function Init_Component return Boolean;
10508 -- Check whether this is the initialization of a component within an
10509 -- init proc (by assignment or call to another init proc). If true,
10510 -- there is no need for a discriminant check.
10512 --------------------
10513 -- Init_Component --
10514 --------------------
10516 function Init_Component return Boolean is
10518 return Inside_Init_Proc
10519 and then Nkind (Prefix (N)) = N_Identifier
10520 and then Chars (Prefix (N)) = Name_uInit
10521 and then Nkind (Parent (Parent (N))) = N_Case_Statement_Alternative;
10522 end Init_Component;
10524 -- Start of processing for Resolve_Selected_Component
10527 if Is_Overloaded (P) then
10529 -- Use the context type to select the prefix that has a selector
10530 -- of the correct name and type.
10533 Get_First_Interp (P, I, It);
10535 Search : while Present (It.Typ) loop
10536 if Is_Access_Type (It.Typ) then
10537 T := Designated_Type (It.Typ);
10542 -- Locate selected component. For a private prefix the selector
10543 -- can denote a discriminant.
10545 if Is_Record_Type (T) or else Is_Private_Type (T) then
10547 -- The visible components of a class-wide type are those of
10550 if Is_Class_Wide_Type (T) then
10554 Comp := First_Entity (T);
10555 while Present (Comp) loop
10556 if Chars (Comp) = Chars (S)
10557 and then Covers (Typ, Etype (Comp))
10566 It := Disambiguate (P, I1, I, Any_Type);
10568 if It = No_Interp then
10570 ("ambiguous prefix for selected component", N);
10571 Set_Etype (N, Typ);
10577 -- There may be an implicit dereference. Retrieve
10578 -- designated record type.
10580 if Is_Access_Type (It1.Typ) then
10581 T := Designated_Type (It1.Typ);
10586 if Scope (Comp1) /= T then
10588 -- Resolution chooses the new interpretation.
10589 -- Find the component with the right name.
10591 Comp1 := First_Entity (T);
10592 while Present (Comp1)
10593 and then Chars (Comp1) /= Chars (S)
10595 Comp1 := Next_Entity (Comp1);
10604 Comp := Next_Entity (Comp);
10608 Get_Next_Interp (I, It);
10611 -- There must be a legal interpretation at this point
10613 pragma Assert (Found);
10614 Resolve (P, It1.Typ);
10616 -- In general the expected type is the type of the context, not the
10617 -- type of the candidate selected component.
10619 Set_Etype (N, Typ);
10620 Set_Entity_With_Checks (S, Comp1);
10622 -- The type of the context and that of the component are
10623 -- compatible and in general identical, but if they are anonymous
10624 -- access-to-subprogram types, the relevant type is that of the
10625 -- component. This matters in Unnest_Subprograms mode, where the
10626 -- relevant context is the one in which the type is declared, not
10627 -- the point of use. This determines what activation record to use.
10629 if Ekind (Typ) = E_Anonymous_Access_Subprogram_Type then
10630 Set_Etype (N, Etype (Comp1));
10632 -- When the type of the component is an access to a class-wide type
10633 -- the relevant type is that of the component (since in such case we
10634 -- may need to generate implicit type conversions or dispatching
10637 elsif Is_Access_Type (Typ)
10638 and then not Is_Class_Wide_Type (Designated_Type (Typ))
10639 and then Is_Class_Wide_Type (Designated_Type (Etype (Comp1)))
10641 Set_Etype (N, Etype (Comp1));
10645 -- Resolve prefix with its type
10650 -- Generate cross-reference. We needed to wait until full overloading
10651 -- resolution was complete to do this, since otherwise we can't tell if
10652 -- we are an lvalue or not.
10654 if May_Be_Lvalue (N) then
10655 Generate_Reference (Entity (S), S, 'm');
10657 Generate_Reference (Entity (S), S, 'r');
10660 -- If prefix is an access type, the node will be transformed into an
10661 -- explicit dereference during expansion. The type of the node is the
10662 -- designated type of that of the prefix.
10664 if Is_Access_Type (Etype (P)) then
10665 T := Designated_Type (Etype (P));
10666 Check_Fully_Declared_Prefix (T, P);
10671 -- If the prefix is an entity it may have a deferred reference set
10672 -- during analysis of the selected component. After resolution we
10673 -- can transform it into a proper reference. This prevents spurious
10674 -- warnings on useless assignments when the same selected component
10675 -- is the actual for an out parameter in a subsequent call.
10677 if Is_Entity_Name (P)
10678 and then Has_Deferred_Reference (Entity (P))
10680 if May_Be_Lvalue (N) then
10681 Generate_Reference (Entity (P), P, 'm');
10683 Generate_Reference (Entity (P), P, 'r');
10688 -- Set flag for expander if discriminant check required on a component
10689 -- appearing within a variant.
10691 if Has_Discriminants (T)
10692 and then Ekind (Entity (S)) = E_Component
10693 and then Present (Original_Record_Component (Entity (S)))
10694 and then Ekind (Original_Record_Component (Entity (S))) = E_Component
10696 Is_Declared_Within_Variant (Original_Record_Component (Entity (S)))
10697 and then not Discriminant_Checks_Suppressed (T)
10698 and then not Init_Component
10700 Set_Do_Discriminant_Check (N);
10703 if Ekind (Entity (S)) = E_Void then
10704 Error_Msg_N ("premature use of component", S);
10707 -- If the prefix is a record conversion, this may be a renamed
10708 -- discriminant whose bounds differ from those of the original
10709 -- one, so we must ensure that a range check is performed.
10711 if Nkind (P) = N_Type_Conversion
10712 and then Ekind (Entity (S)) = E_Discriminant
10713 and then Is_Discrete_Type (Typ)
10715 Set_Etype (N, Base_Type (Typ));
10718 -- Note: No Eval processing is required, because the prefix is of a
10719 -- record type, or protected type, and neither can possibly be static.
10721 -- If the record type is atomic, and the component is non-atomic, then
10722 -- this is worth a warning, since we have a situation where the access
10723 -- to the component may cause extra read/writes of the atomic array
10724 -- object, or partial word accesses, both of which may be unexpected.
10726 if Nkind (N) = N_Selected_Component
10727 and then Is_Atomic_Ref_With_Address (N)
10728 and then not Is_Atomic (Entity (S))
10729 and then not Is_Atomic (Etype (Entity (S)))
10732 ("??access to non-atomic component of atomic record",
10735 ("\??may cause unexpected accesses to atomic object",
10739 Analyze_Dimension (N);
10740 end Resolve_Selected_Component;
10742 -------------------
10743 -- Resolve_Shift --
10744 -------------------
10746 procedure Resolve_Shift (N : Node_Id; Typ : Entity_Id) is
10747 B_Typ : constant Entity_Id := Base_Type (Typ);
10748 L : constant Node_Id := Left_Opnd (N);
10749 R : constant Node_Id := Right_Opnd (N);
10752 -- We do the resolution using the base type, because intermediate values
10753 -- in expressions always are of the base type, not a subtype of it.
10755 Resolve (L, B_Typ);
10756 Resolve (R, Standard_Natural);
10758 Check_Unset_Reference (L);
10759 Check_Unset_Reference (R);
10761 Set_Etype (N, B_Typ);
10762 Generate_Operator_Reference (N, B_Typ);
10766 ---------------------------
10767 -- Resolve_Short_Circuit --
10768 ---------------------------
10770 procedure Resolve_Short_Circuit (N : Node_Id; Typ : Entity_Id) is
10771 B_Typ : constant Entity_Id := Base_Type (Typ);
10772 L : constant Node_Id := Left_Opnd (N);
10773 R : constant Node_Id := Right_Opnd (N);
10776 -- Ensure all actions associated with the left operand (e.g.
10777 -- finalization of transient objects) are fully evaluated locally within
10778 -- an expression with actions. This is particularly helpful for coverage
10779 -- analysis. However this should not happen in generics or if option
10780 -- Minimize_Expression_With_Actions is set.
10782 if Expander_Active and not Minimize_Expression_With_Actions then
10784 Reloc_L : constant Node_Id := Relocate_Node (L);
10786 Save_Interps (Old_N => L, New_N => Reloc_L);
10789 Make_Expression_With_Actions (Sloc (L),
10790 Actions => New_List,
10791 Expression => Reloc_L));
10793 -- Set Comes_From_Source on L to preserve warnings for unset
10796 Set_Comes_From_Source (L, Comes_From_Source (Reloc_L));
10800 Resolve (L, B_Typ);
10801 Resolve (R, B_Typ);
10803 -- Check for issuing warning for always False assert/check, this happens
10804 -- when assertions are turned off, in which case the pragma Assert/Check
10805 -- was transformed into:
10807 -- if False and then <condition> then ...
10809 -- and we detect this pattern
10811 if Warn_On_Assertion_Failure
10812 and then Is_Entity_Name (R)
10813 and then Entity (R) = Standard_False
10814 and then Nkind (Parent (N)) = N_If_Statement
10815 and then Nkind (N) = N_And_Then
10816 and then Is_Entity_Name (L)
10817 and then Entity (L) = Standard_False
10820 Orig : constant Node_Id := Original_Node (Parent (N));
10823 -- Special handling of Asssert pragma
10825 if Nkind (Orig) = N_Pragma
10826 and then Pragma_Name (Orig) = Name_Assert
10829 Expr : constant Node_Id :=
10832 (First (Pragma_Argument_Associations (Orig))));
10835 -- Don't warn if original condition is explicit False,
10836 -- since obviously the failure is expected in this case.
10838 if Is_Entity_Name (Expr)
10839 and then Entity (Expr) = Standard_False
10843 -- Issue warning. We do not want the deletion of the
10844 -- IF/AND-THEN to take this message with it. We achieve this
10845 -- by making sure that the expanded code points to the Sloc
10846 -- of the expression, not the original pragma.
10849 -- Note: Use Error_Msg_F here rather than Error_Msg_N.
10850 -- The source location of the expression is not usually
10851 -- the best choice here. For example, it gets located on
10852 -- the last AND keyword in a chain of boolean expressiond
10853 -- AND'ed together. It is best to put the message on the
10854 -- first character of the assertion, which is the effect
10855 -- of the First_Node call here.
10858 ("?A?assertion would fail at run time!",
10860 (First (Pragma_Argument_Associations (Orig))));
10864 -- Similar processing for Check pragma
10866 elsif Nkind (Orig) = N_Pragma
10867 and then Pragma_Name (Orig) = Name_Check
10869 -- Don't want to warn if original condition is explicit False
10872 Expr : constant Node_Id :=
10875 (Next (First (Pragma_Argument_Associations (Orig)))));
10877 if Is_Entity_Name (Expr)
10878 and then Entity (Expr) = Standard_False
10885 -- Again use Error_Msg_F rather than Error_Msg_N, see
10886 -- comment above for an explanation of why we do this.
10889 ("?A?check would fail at run time!",
10891 (Last (Pragma_Argument_Associations (Orig))));
10898 -- Continue with processing of short circuit
10900 Check_Unset_Reference (L);
10901 Check_Unset_Reference (R);
10903 Set_Etype (N, B_Typ);
10904 Eval_Short_Circuit (N);
10905 end Resolve_Short_Circuit;
10907 -------------------
10908 -- Resolve_Slice --
10909 -------------------
10911 procedure Resolve_Slice (N : Node_Id; Typ : Entity_Id) is
10912 Drange : constant Node_Id := Discrete_Range (N);
10913 Name : constant Node_Id := Prefix (N);
10914 Array_Type : Entity_Id := Empty;
10915 Dexpr : Node_Id := Empty;
10916 Index_Type : Entity_Id;
10919 if Is_Overloaded (Name) then
10921 -- Use the context type to select the prefix that yields the correct
10926 I1 : Interp_Index := 0;
10928 P : constant Node_Id := Prefix (N);
10929 Found : Boolean := False;
10932 Get_First_Interp (P, I, It);
10933 while Present (It.Typ) loop
10934 if (Is_Array_Type (It.Typ)
10935 and then Covers (Typ, It.Typ))
10936 or else (Is_Access_Type (It.Typ)
10937 and then Is_Array_Type (Designated_Type (It.Typ))
10938 and then Covers (Typ, Designated_Type (It.Typ)))
10941 It := Disambiguate (P, I1, I, Any_Type);
10943 if It = No_Interp then
10944 Error_Msg_N ("ambiguous prefix for slicing", N);
10945 Set_Etype (N, Typ);
10949 Array_Type := It.Typ;
10954 Array_Type := It.Typ;
10959 Get_Next_Interp (I, It);
10964 Array_Type := Etype (Name);
10967 Resolve (Name, Array_Type);
10969 if Is_Access_Type (Array_Type) then
10970 Apply_Access_Check (N);
10971 Array_Type := Designated_Type (Array_Type);
10973 -- If the prefix is an access to an unconstrained array, we must use
10974 -- the actual subtype of the object to perform the index checks. The
10975 -- object denoted by the prefix is implicit in the node, so we build
10976 -- an explicit representation for it in order to compute the actual
10979 if not Is_Constrained (Array_Type) then
10980 Remove_Side_Effects (Prefix (N));
10983 Obj : constant Node_Id :=
10984 Make_Explicit_Dereference (Sloc (N),
10985 Prefix => New_Copy_Tree (Prefix (N)));
10987 Set_Etype (Obj, Array_Type);
10988 Set_Parent (Obj, Parent (N));
10989 Array_Type := Get_Actual_Subtype (Obj);
10993 elsif Is_Entity_Name (Name)
10994 or else Nkind (Name) = N_Explicit_Dereference
10995 or else (Nkind (Name) = N_Function_Call
10996 and then not Is_Constrained (Etype (Name)))
10998 Array_Type := Get_Actual_Subtype (Name);
11000 -- If the name is a selected component that depends on discriminants,
11001 -- build an actual subtype for it. This can happen only when the name
11002 -- itself is overloaded; otherwise the actual subtype is created when
11003 -- the selected component is analyzed.
11005 elsif Nkind (Name) = N_Selected_Component
11006 and then Full_Analysis
11007 and then Depends_On_Discriminant (First_Index (Array_Type))
11010 Act_Decl : constant Node_Id :=
11011 Build_Actual_Subtype_Of_Component (Array_Type, Name);
11013 Insert_Action (N, Act_Decl);
11014 Array_Type := Defining_Identifier (Act_Decl);
11017 -- Maybe this should just be "else", instead of checking for the
11018 -- specific case of slice??? This is needed for the case where the
11019 -- prefix is an Image attribute, which gets expanded to a slice, and so
11020 -- has a constrained subtype which we want to use for the slice range
11021 -- check applied below (the range check won't get done if the
11022 -- unconstrained subtype of the 'Image is used).
11024 elsif Nkind (Name) = N_Slice then
11025 Array_Type := Etype (Name);
11028 -- Obtain the type of the array index
11030 if Ekind (Array_Type) = E_String_Literal_Subtype then
11031 Index_Type := Etype (String_Literal_Low_Bound (Array_Type));
11033 Index_Type := Etype (First_Index (Array_Type));
11036 -- If name was overloaded, set slice type correctly now
11038 Set_Etype (N, Array_Type);
11040 -- Handle the generation of a range check that compares the array index
11041 -- against the discrete_range. The check is not applied to internally
11042 -- built nodes associated with the expansion of dispatch tables. Check
11043 -- that Ada.Tags has already been loaded to avoid extra dependencies on
11046 if Tagged_Type_Expansion
11047 and then RTU_Loaded (Ada_Tags)
11048 and then Nkind (Prefix (N)) = N_Selected_Component
11049 and then Present (Entity (Selector_Name (Prefix (N))))
11050 and then Entity (Selector_Name (Prefix (N))) =
11051 RTE_Record_Component (RE_Prims_Ptr)
11055 -- The discrete_range is specified by a subtype indication. Create a
11056 -- shallow copy and inherit the type, parent and source location from
11057 -- the discrete_range. This ensures that the range check is inserted
11058 -- relative to the slice and that the runtime exception points to the
11059 -- proper construct.
11061 elsif Is_Entity_Name (Drange) then
11062 Dexpr := New_Copy (Scalar_Range (Entity (Drange)));
11064 Set_Etype (Dexpr, Etype (Drange));
11065 Set_Parent (Dexpr, Parent (Drange));
11066 Set_Sloc (Dexpr, Sloc (Drange));
11068 -- The discrete_range is a regular range. Resolve the bounds and remove
11069 -- their side effects.
11072 Resolve (Drange, Base_Type (Index_Type));
11074 if Nkind (Drange) = N_Range then
11075 Force_Evaluation (Low_Bound (Drange));
11076 Force_Evaluation (High_Bound (Drange));
11082 if Present (Dexpr) then
11083 Apply_Range_Check (Dexpr, Index_Type);
11086 Set_Slice_Subtype (N);
11088 -- Check bad use of type with predicates
11094 if Nkind (Drange) = N_Subtype_Indication
11095 and then Has_Predicates (Entity (Subtype_Mark (Drange)))
11097 Subt := Entity (Subtype_Mark (Drange));
11099 Subt := Etype (Drange);
11102 if Has_Predicates (Subt) then
11103 Bad_Predicated_Subtype_Use
11104 ("subtype& has predicate, not allowed in slice", Drange, Subt);
11108 -- Otherwise here is where we check suspicious indexes
11110 if Nkind (Drange) = N_Range then
11111 Warn_On_Suspicious_Index (Name, Low_Bound (Drange));
11112 Warn_On_Suspicious_Index (Name, High_Bound (Drange));
11115 Analyze_Dimension (N);
11119 ----------------------------
11120 -- Resolve_String_Literal --
11121 ----------------------------
11123 procedure Resolve_String_Literal (N : Node_Id; Typ : Entity_Id) is
11124 C_Typ : constant Entity_Id := Component_Type (Typ);
11125 R_Typ : constant Entity_Id := Root_Type (C_Typ);
11126 Loc : constant Source_Ptr := Sloc (N);
11127 Str : constant String_Id := Strval (N);
11128 Strlen : constant Nat := String_Length (Str);
11129 Subtype_Id : Entity_Id;
11130 Need_Check : Boolean;
11133 -- For a string appearing in a concatenation, defer creation of the
11134 -- string_literal_subtype until the end of the resolution of the
11135 -- concatenation, because the literal may be constant-folded away. This
11136 -- is a useful optimization for long concatenation expressions.
11138 -- If the string is an aggregate built for a single character (which
11139 -- happens in a non-static context) or a is null string to which special
11140 -- checks may apply, we build the subtype. Wide strings must also get a
11141 -- string subtype if they come from a one character aggregate. Strings
11142 -- generated by attributes might be static, but it is often hard to
11143 -- determine whether the enclosing context is static, so we generate
11144 -- subtypes for them as well, thus losing some rarer optimizations ???
11145 -- Same for strings that come from a static conversion.
11148 (Strlen = 0 and then Typ /= Standard_String)
11149 or else Nkind (Parent (N)) /= N_Op_Concat
11150 or else (N /= Left_Opnd (Parent (N))
11151 and then N /= Right_Opnd (Parent (N)))
11152 or else ((Typ = Standard_Wide_String
11153 or else Typ = Standard_Wide_Wide_String)
11154 and then Nkind (Original_Node (N)) /= N_String_Literal);
11156 -- If the resolving type is itself a string literal subtype, we can just
11157 -- reuse it, since there is no point in creating another.
11159 if Ekind (Typ) = E_String_Literal_Subtype then
11162 elsif Nkind (Parent (N)) = N_Op_Concat
11163 and then not Need_Check
11164 and then not Nkind_In (Original_Node (N), N_Character_Literal,
11165 N_Attribute_Reference,
11166 N_Qualified_Expression,
11171 -- Do not generate a string literal subtype for the default expression
11172 -- of a formal parameter in GNATprove mode. This is because the string
11173 -- subtype is associated with the freezing actions of the subprogram,
11174 -- however freezing is disabled in GNATprove mode and as a result the
11175 -- subtype is unavailable.
11177 elsif GNATprove_Mode
11178 and then Nkind (Parent (N)) = N_Parameter_Specification
11182 -- Otherwise we must create a string literal subtype. Note that the
11183 -- whole idea of string literal subtypes is simply to avoid the need
11184 -- for building a full fledged array subtype for each literal.
11187 Set_String_Literal_Subtype (N, Typ);
11188 Subtype_Id := Etype (N);
11191 if Nkind (Parent (N)) /= N_Op_Concat
11194 Set_Etype (N, Subtype_Id);
11195 Eval_String_Literal (N);
11198 if Is_Limited_Composite (Typ)
11199 or else Is_Private_Composite (Typ)
11201 Error_Msg_N ("string literal not available for private array", N);
11202 Set_Etype (N, Any_Type);
11206 -- The validity of a null string has been checked in the call to
11207 -- Eval_String_Literal.
11212 -- Always accept string literal with component type Any_Character, which
11213 -- occurs in error situations and in comparisons of literals, both of
11214 -- which should accept all literals.
11216 elsif R_Typ = Any_Character then
11219 -- If the type is bit-packed, then we always transform the string
11220 -- literal into a full fledged aggregate.
11222 elsif Is_Bit_Packed_Array (Typ) then
11225 -- Deal with cases of Wide_Wide_String, Wide_String, and String
11228 -- For Standard.Wide_Wide_String, or any other type whose component
11229 -- type is Standard.Wide_Wide_Character, we know that all the
11230 -- characters in the string must be acceptable, since the parser
11231 -- accepted the characters as valid character literals.
11233 if R_Typ = Standard_Wide_Wide_Character then
11236 -- For the case of Standard.String, or any other type whose component
11237 -- type is Standard.Character, we must make sure that there are no
11238 -- wide characters in the string, i.e. that it is entirely composed
11239 -- of characters in range of type Character.
11241 -- If the string literal is the result of a static concatenation, the
11242 -- test has already been performed on the components, and need not be
11245 elsif R_Typ = Standard_Character
11246 and then Nkind (Original_Node (N)) /= N_Op_Concat
11248 for J in 1 .. Strlen loop
11249 if not In_Character_Range (Get_String_Char (Str, J)) then
11251 -- If we are out of range, post error. This is one of the
11252 -- very few places that we place the flag in the middle of
11253 -- a token, right under the offending wide character. Not
11254 -- quite clear if this is right wrt wide character encoding
11255 -- sequences, but it's only an error message.
11258 ("literal out of range of type Standard.Character",
11259 Source_Ptr (Int (Loc) + J));
11264 -- For the case of Standard.Wide_String, or any other type whose
11265 -- component type is Standard.Wide_Character, we must make sure that
11266 -- there are no wide characters in the string, i.e. that it is
11267 -- entirely composed of characters in range of type Wide_Character.
11269 -- If the string literal is the result of a static concatenation,
11270 -- the test has already been performed on the components, and need
11271 -- not be repeated.
11273 elsif R_Typ = Standard_Wide_Character
11274 and then Nkind (Original_Node (N)) /= N_Op_Concat
11276 for J in 1 .. Strlen loop
11277 if not In_Wide_Character_Range (Get_String_Char (Str, J)) then
11279 -- If we are out of range, post error. This is one of the
11280 -- very few places that we place the flag in the middle of
11281 -- a token, right under the offending wide character.
11283 -- This is not quite right, because characters in general
11284 -- will take more than one character position ???
11287 ("literal out of range of type Standard.Wide_Character",
11288 Source_Ptr (Int (Loc) + J));
11293 -- If the root type is not a standard character, then we will convert
11294 -- the string into an aggregate and will let the aggregate code do
11295 -- the checking. Standard Wide_Wide_Character is also OK here.
11301 -- See if the component type of the array corresponding to the string
11302 -- has compile time known bounds. If yes we can directly check
11303 -- whether the evaluation of the string will raise constraint error.
11304 -- Otherwise we need to transform the string literal into the
11305 -- corresponding character aggregate and let the aggregate code do
11306 -- the checking. We use the same transformation if the component
11307 -- type has a static predicate, which will be applied to each
11308 -- character when the aggregate is resolved.
11310 if Is_Standard_Character_Type (R_Typ) then
11312 -- Check for the case of full range, where we are definitely OK
11314 if Component_Type (Typ) = Base_Type (Component_Type (Typ)) then
11318 -- Here the range is not the complete base type range, so check
11321 Comp_Typ_Lo : constant Node_Id :=
11322 Type_Low_Bound (Component_Type (Typ));
11323 Comp_Typ_Hi : constant Node_Id :=
11324 Type_High_Bound (Component_Type (Typ));
11329 if Compile_Time_Known_Value (Comp_Typ_Lo)
11330 and then Compile_Time_Known_Value (Comp_Typ_Hi)
11332 for J in 1 .. Strlen loop
11333 Char_Val := UI_From_Int (Int (Get_String_Char (Str, J)));
11335 if Char_Val < Expr_Value (Comp_Typ_Lo)
11336 or else Char_Val > Expr_Value (Comp_Typ_Hi)
11338 Apply_Compile_Time_Constraint_Error
11339 (N, "character out of range??",
11340 CE_Range_Check_Failed,
11341 Loc => Source_Ptr (Int (Loc) + J));
11345 if not Has_Static_Predicate (C_Typ) then
11353 -- If we got here we meed to transform the string literal into the
11354 -- equivalent qualified positional array aggregate. This is rather
11355 -- heavy artillery for this situation, but it is hard work to avoid.
11358 Lits : constant List_Id := New_List;
11359 P : Source_Ptr := Loc + 1;
11363 -- Build the character literals, we give them source locations that
11364 -- correspond to the string positions, which is a bit tricky given
11365 -- the possible presence of wide character escape sequences.
11367 for J in 1 .. Strlen loop
11368 C := Get_String_Char (Str, J);
11369 Set_Character_Literal_Name (C);
11372 Make_Character_Literal (P,
11373 Chars => Name_Find,
11374 Char_Literal_Value => UI_From_CC (C)));
11376 if In_Character_Range (C) then
11379 -- Should we have a call to Skip_Wide here ???
11388 Make_Qualified_Expression (Loc,
11389 Subtype_Mark => New_Occurrence_Of (Typ, Loc),
11391 Make_Aggregate (Loc, Expressions => Lits)));
11393 Analyze_And_Resolve (N, Typ);
11395 end Resolve_String_Literal;
11397 -------------------------
11398 -- Resolve_Target_Name --
11399 -------------------------
11401 procedure Resolve_Target_Name (N : Node_Id; Typ : Entity_Id) is
11403 Set_Etype (N, Typ);
11404 end Resolve_Target_Name;
11406 -----------------------------
11407 -- Resolve_Type_Conversion --
11408 -----------------------------
11410 procedure Resolve_Type_Conversion (N : Node_Id; Typ : Entity_Id) is
11411 Conv_OK : constant Boolean := Conversion_OK (N);
11412 Operand : constant Node_Id := Expression (N);
11413 Operand_Typ : constant Entity_Id := Etype (Operand);
11414 Target_Typ : constant Entity_Id := Etype (N);
11419 Test_Redundant : Boolean := Warn_On_Redundant_Constructs;
11420 -- Set to False to suppress cases where we want to suppress the test
11421 -- for redundancy to avoid possible false positives on this warning.
11425 and then not Valid_Conversion (N, Target_Typ, Operand)
11430 -- If the Operand Etype is Universal_Fixed, then the conversion is
11431 -- never redundant. We need this check because by the time we have
11432 -- finished the rather complex transformation, the conversion looks
11433 -- redundant when it is not.
11435 if Operand_Typ = Universal_Fixed then
11436 Test_Redundant := False;
11438 -- If the operand is marked as Any_Fixed, then special processing is
11439 -- required. This is also a case where we suppress the test for a
11440 -- redundant conversion, since most certainly it is not redundant.
11442 elsif Operand_Typ = Any_Fixed then
11443 Test_Redundant := False;
11445 -- Mixed-mode operation involving a literal. Context must be a fixed
11446 -- type which is applied to the literal subsequently.
11448 -- Multiplication and division involving two fixed type operands must
11449 -- yield a universal real because the result is computed in arbitrary
11452 if Is_Fixed_Point_Type (Typ)
11453 and then Nkind_In (Operand, N_Op_Divide, N_Op_Multiply)
11454 and then Etype (Left_Opnd (Operand)) = Any_Fixed
11455 and then Etype (Right_Opnd (Operand)) = Any_Fixed
11457 Set_Etype (Operand, Universal_Real);
11459 elsif Is_Numeric_Type (Typ)
11460 and then Nkind_In (Operand, N_Op_Multiply, N_Op_Divide)
11461 and then (Etype (Right_Opnd (Operand)) = Universal_Real
11463 Etype (Left_Opnd (Operand)) = Universal_Real)
11465 -- Return if expression is ambiguous
11467 if Unique_Fixed_Point_Type (N) = Any_Type then
11470 -- If nothing else, the available fixed type is Duration
11473 Set_Etype (Operand, Standard_Duration);
11476 -- Resolve the real operand with largest available precision
11478 if Etype (Right_Opnd (Operand)) = Universal_Real then
11479 Rop := New_Copy_Tree (Right_Opnd (Operand));
11481 Rop := New_Copy_Tree (Left_Opnd (Operand));
11484 Resolve (Rop, Universal_Real);
11486 -- If the operand is a literal (it could be a non-static and
11487 -- illegal exponentiation) check whether the use of Duration
11488 -- is potentially inaccurate.
11490 if Nkind (Rop) = N_Real_Literal
11491 and then Realval (Rop) /= Ureal_0
11492 and then abs (Realval (Rop)) < Delta_Value (Standard_Duration)
11495 ("??universal real operand can only "
11496 & "be interpreted as Duration!", Rop);
11498 ("\??precision will be lost in the conversion!", Rop);
11501 elsif Is_Numeric_Type (Typ)
11502 and then Nkind (Operand) in N_Op
11503 and then Unique_Fixed_Point_Type (N) /= Any_Type
11505 Set_Etype (Operand, Standard_Duration);
11508 Error_Msg_N ("invalid context for mixed mode operation", N);
11509 Set_Etype (Operand, Any_Type);
11516 -- In SPARK, a type conversion between array types should be restricted
11517 -- to types which have matching static bounds.
11519 -- Protect call to Matching_Static_Array_Bounds to avoid costly
11520 -- operation if not needed.
11522 if Restriction_Check_Required (SPARK_05)
11523 and then Is_Array_Type (Target_Typ)
11524 and then Is_Array_Type (Operand_Typ)
11525 and then Operand_Typ /= Any_Composite -- or else Operand in error
11526 and then not Matching_Static_Array_Bounds (Target_Typ, Operand_Typ)
11528 Check_SPARK_05_Restriction
11529 ("array types should have matching static bounds", N);
11532 -- In formal mode, the operand of an ancestor type conversion must be an
11533 -- object (not an expression).
11535 if Is_Tagged_Type (Target_Typ)
11536 and then not Is_Class_Wide_Type (Target_Typ)
11537 and then Is_Tagged_Type (Operand_Typ)
11538 and then not Is_Class_Wide_Type (Operand_Typ)
11539 and then Is_Ancestor (Target_Typ, Operand_Typ)
11540 and then not Is_SPARK_05_Object_Reference (Operand)
11542 Check_SPARK_05_Restriction ("object required", Operand);
11545 Analyze_Dimension (N);
11547 -- Note: we do the Eval_Type_Conversion call before applying the
11548 -- required checks for a subtype conversion. This is important, since
11549 -- both are prepared under certain circumstances to change the type
11550 -- conversion to a constraint error node, but in the case of
11551 -- Eval_Type_Conversion this may reflect an illegality in the static
11552 -- case, and we would miss the illegality (getting only a warning
11553 -- message), if we applied the type conversion checks first.
11555 Eval_Type_Conversion (N);
11557 -- Even when evaluation is not possible, we may be able to simplify the
11558 -- conversion or its expression. This needs to be done before applying
11559 -- checks, since otherwise the checks may use the original expression
11560 -- and defeat the simplifications. This is specifically the case for
11561 -- elimination of the floating-point Truncation attribute in
11562 -- float-to-int conversions.
11564 Simplify_Type_Conversion (N);
11566 -- If after evaluation we still have a type conversion, then we may need
11567 -- to apply checks required for a subtype conversion.
11569 -- Skip these type conversion checks if universal fixed operands
11570 -- operands involved, since range checks are handled separately for
11571 -- these cases (in the appropriate Expand routines in unit Exp_Fixd).
11573 if Nkind (N) = N_Type_Conversion
11574 and then not Is_Generic_Type (Root_Type (Target_Typ))
11575 and then Target_Typ /= Universal_Fixed
11576 and then Operand_Typ /= Universal_Fixed
11578 Apply_Type_Conversion_Checks (N);
11581 -- Issue warning for conversion of simple object to its own type. We
11582 -- have to test the original nodes, since they may have been rewritten
11583 -- by various optimizations.
11585 Orig_N := Original_Node (N);
11587 -- Here we test for a redundant conversion if the warning mode is
11588 -- active (and was not locally reset), and we have a type conversion
11589 -- from source not appearing in a generic instance.
11592 and then Nkind (Orig_N) = N_Type_Conversion
11593 and then Comes_From_Source (Orig_N)
11594 and then not In_Instance
11596 Orig_N := Original_Node (Expression (Orig_N));
11597 Orig_T := Target_Typ;
11599 -- If the node is part of a larger expression, the Target_Type
11600 -- may not be the original type of the node if the context is a
11601 -- condition. Recover original type to see if conversion is needed.
11603 if Is_Boolean_Type (Orig_T)
11604 and then Nkind (Parent (N)) in N_Op
11606 Orig_T := Etype (Parent (N));
11609 -- If we have an entity name, then give the warning if the entity
11610 -- is the right type, or if it is a loop parameter covered by the
11611 -- original type (that's needed because loop parameters have an
11612 -- odd subtype coming from the bounds).
11614 if (Is_Entity_Name (Orig_N)
11616 (Etype (Entity (Orig_N)) = Orig_T
11618 (Ekind (Entity (Orig_N)) = E_Loop_Parameter
11619 and then Covers (Orig_T, Etype (Entity (Orig_N))))))
11621 -- If not an entity, then type of expression must match
11623 or else Etype (Orig_N) = Orig_T
11625 -- One more check, do not give warning if the analyzed conversion
11626 -- has an expression with non-static bounds, and the bounds of the
11627 -- target are static. This avoids junk warnings in cases where the
11628 -- conversion is necessary to establish staticness, for example in
11629 -- a case statement.
11631 if not Is_OK_Static_Subtype (Operand_Typ)
11632 and then Is_OK_Static_Subtype (Target_Typ)
11636 -- Finally, if this type conversion occurs in a context requiring
11637 -- a prefix, and the expression is a qualified expression then the
11638 -- type conversion is not redundant, since a qualified expression
11639 -- is not a prefix, whereas a type conversion is. For example, "X
11640 -- := T'(Funx(...)).Y;" is illegal because a selected component
11641 -- requires a prefix, but a type conversion makes it legal: "X :=
11642 -- T(T'(Funx(...))).Y;"
11644 -- In Ada 2012, a qualified expression is a name, so this idiom is
11645 -- no longer needed, but we still suppress the warning because it
11646 -- seems unfriendly for warnings to pop up when you switch to the
11647 -- newer language version.
11649 elsif Nkind (Orig_N) = N_Qualified_Expression
11650 and then Nkind_In (Parent (N), N_Attribute_Reference,
11651 N_Indexed_Component,
11652 N_Selected_Component,
11654 N_Explicit_Dereference)
11658 -- Never warn on conversion to Long_Long_Integer'Base since
11659 -- that is most likely an artifact of the extended overflow
11660 -- checking and comes from complex expanded code.
11662 elsif Orig_T = Base_Type (Standard_Long_Long_Integer) then
11665 -- Here we give the redundant conversion warning. If it is an
11666 -- entity, give the name of the entity in the message. If not,
11667 -- just mention the expression.
11669 -- Shoudn't we test Warn_On_Redundant_Constructs here ???
11672 if Is_Entity_Name (Orig_N) then
11673 Error_Msg_Node_2 := Orig_T;
11674 Error_Msg_NE -- CODEFIX
11675 ("??redundant conversion, & is of type &!",
11676 N, Entity (Orig_N));
11679 ("??redundant conversion, expression is of type&!",
11686 -- Ada 2005 (AI-251): Handle class-wide interface type conversions.
11687 -- No need to perform any interface conversion if the type of the
11688 -- expression coincides with the target type.
11690 if Ada_Version >= Ada_2005
11691 and then Expander_Active
11692 and then Operand_Typ /= Target_Typ
11695 Opnd : Entity_Id := Operand_Typ;
11696 Target : Entity_Id := Target_Typ;
11699 -- If the type of the operand is a limited view, use nonlimited
11700 -- view when available. If it is a class-wide type, recover the
11701 -- class-wide type of the nonlimited view.
11703 if From_Limited_With (Opnd)
11704 and then Has_Non_Limited_View (Opnd)
11706 Opnd := Non_Limited_View (Opnd);
11707 Set_Etype (Expression (N), Opnd);
11710 if Is_Access_Type (Opnd) then
11711 Opnd := Designated_Type (Opnd);
11714 if Is_Access_Type (Target_Typ) then
11715 Target := Designated_Type (Target);
11718 if Opnd = Target then
11721 -- Conversion from interface type
11723 elsif Is_Interface (Opnd) then
11725 -- Ada 2005 (AI-217): Handle entities from limited views
11727 if From_Limited_With (Opnd) then
11728 Error_Msg_Qual_Level := 99;
11729 Error_Msg_NE -- CODEFIX
11730 ("missing WITH clause on package &", N,
11731 Cunit_Entity (Get_Source_Unit (Base_Type (Opnd))));
11733 ("type conversions require visibility of the full view",
11736 elsif From_Limited_With (Target)
11738 (Is_Access_Type (Target_Typ)
11739 and then Present (Non_Limited_View (Etype (Target))))
11741 Error_Msg_Qual_Level := 99;
11742 Error_Msg_NE -- CODEFIX
11743 ("missing WITH clause on package &", N,
11744 Cunit_Entity (Get_Source_Unit (Base_Type (Target))));
11746 ("type conversions require visibility of the full view",
11750 Expand_Interface_Conversion (N);
11753 -- Conversion to interface type
11755 elsif Is_Interface (Target) then
11759 if Ekind_In (Opnd, E_Protected_Subtype, E_Task_Subtype) then
11760 Opnd := Etype (Opnd);
11763 if Is_Class_Wide_Type (Opnd)
11764 or else Interface_Present_In_Ancestor
11768 Expand_Interface_Conversion (N);
11770 Error_Msg_Name_1 := Chars (Etype (Target));
11771 Error_Msg_Name_2 := Chars (Opnd);
11773 ("wrong interface conversion (% is not a progenitor "
11780 -- Ada 2012: once the type conversion is resolved, check whether the
11781 -- operand statisfies the static predicate of the target type.
11783 if Has_Predicates (Target_Typ) then
11784 Check_Expression_Against_Static_Predicate (N, Target_Typ);
11787 -- If at this stage we have a real to integer conversion, make sure that
11788 -- the Do_Range_Check flag is set, because such conversions in general
11789 -- need a range check. We only need this if expansion is off.
11790 -- In GNATprove mode, we only do that when converting from fixed-point
11791 -- (as floating-point to integer conversions are now handled in
11792 -- GNATprove mode).
11794 if Nkind (N) = N_Type_Conversion
11795 and then not Expander_Active
11796 and then Is_Integer_Type (Target_Typ)
11797 and then (Is_Fixed_Point_Type (Operand_Typ)
11798 or else (not GNATprove_Mode
11799 and then Is_Floating_Point_Type (Operand_Typ)))
11800 and then not Range_Checks_Suppressed (Target_Typ)
11801 and then not Range_Checks_Suppressed (Operand_Typ)
11803 Set_Do_Range_Check (Operand);
11806 -- Generating C code a type conversion of an access to constrained
11807 -- array type to access to unconstrained array type involves building
11808 -- a fat pointer which in general cannot be generated on the fly. We
11809 -- remove side effects in order to store the result of the conversion
11810 -- into a temporary.
11812 if Modify_Tree_For_C
11813 and then Nkind (N) = N_Type_Conversion
11814 and then Nkind (Parent (N)) /= N_Object_Declaration
11815 and then Is_Access_Type (Etype (N))
11816 and then Is_Array_Type (Designated_Type (Etype (N)))
11817 and then not Is_Constrained (Designated_Type (Etype (N)))
11818 and then Is_Constrained (Designated_Type (Etype (Expression (N))))
11820 Remove_Side_Effects (N);
11822 end Resolve_Type_Conversion;
11824 ----------------------
11825 -- Resolve_Unary_Op --
11826 ----------------------
11828 procedure Resolve_Unary_Op (N : Node_Id; Typ : Entity_Id) is
11829 B_Typ : constant Entity_Id := Base_Type (Typ);
11830 R : constant Node_Id := Right_Opnd (N);
11836 if Is_Modular_Integer_Type (Typ) and then Nkind (N) /= N_Op_Not then
11837 Error_Msg_Name_1 := Chars (Typ);
11838 Check_SPARK_05_Restriction
11839 ("unary operator not defined for modular type%", N);
11842 -- Deal with intrinsic unary operators
11844 if Comes_From_Source (N)
11845 and then Ekind (Entity (N)) = E_Function
11846 and then Is_Imported (Entity (N))
11847 and then Is_Intrinsic_Subprogram (Entity (N))
11849 Resolve_Intrinsic_Unary_Operator (N, Typ);
11853 -- Deal with universal cases
11855 if Etype (R) = Universal_Integer
11857 Etype (R) = Universal_Real
11859 Check_For_Visible_Operator (N, B_Typ);
11862 Set_Etype (N, B_Typ);
11863 Resolve (R, B_Typ);
11865 -- Generate warning for expressions like abs (x mod 2)
11867 if Warn_On_Redundant_Constructs
11868 and then Nkind (N) = N_Op_Abs
11870 Determine_Range (Right_Opnd (N), OK, Lo, Hi);
11872 if OK and then Hi >= Lo and then Lo >= 0 then
11873 Error_Msg_N -- CODEFIX
11874 ("?r?abs applied to known non-negative value has no effect", N);
11878 -- Deal with reference generation
11880 Check_Unset_Reference (R);
11881 Generate_Operator_Reference (N, B_Typ);
11882 Analyze_Dimension (N);
11885 -- Set overflow checking bit. Much cleverer code needed here eventually
11886 -- and perhaps the Resolve routines should be separated for the various
11887 -- arithmetic operations, since they will need different processing ???
11889 if Nkind (N) in N_Op then
11890 if not Overflow_Checks_Suppressed (Etype (N)) then
11891 Enable_Overflow_Check (N);
11895 -- Generate warning for expressions like -5 mod 3 for integers. No need
11896 -- to worry in the floating-point case, since parens do not affect the
11897 -- result so there is no point in giving in a warning.
11900 Norig : constant Node_Id := Original_Node (N);
11909 if Warn_On_Questionable_Missing_Parens
11910 and then Comes_From_Source (Norig)
11911 and then Is_Integer_Type (Typ)
11912 and then Nkind (Norig) = N_Op_Minus
11914 Rorig := Original_Node (Right_Opnd (Norig));
11916 -- We are looking for cases where the right operand is not
11917 -- parenthesized, and is a binary operator, multiply, divide, or
11918 -- mod. These are the cases where the grouping can affect results.
11920 if Paren_Count (Rorig) = 0
11921 and then Nkind_In (Rorig, N_Op_Mod, N_Op_Multiply, N_Op_Divide)
11923 -- For mod, we always give the warning, since the value is
11924 -- affected by the parenthesization (e.g. (-5) mod 315 /=
11925 -- -(5 mod 315)). But for the other cases, the only concern is
11926 -- overflow, e.g. for the case of 8 big signed (-(2 * 64)
11927 -- overflows, but (-2) * 64 does not). So we try to give the
11928 -- message only when overflow is possible.
11930 if Nkind (Rorig) /= N_Op_Mod
11931 and then Compile_Time_Known_Value (R)
11933 Val := Expr_Value (R);
11935 if Compile_Time_Known_Value (Type_High_Bound (Typ)) then
11936 HB := Expr_Value (Type_High_Bound (Typ));
11938 HB := Expr_Value (Type_High_Bound (Base_Type (Typ)));
11941 if Compile_Time_Known_Value (Type_Low_Bound (Typ)) then
11942 LB := Expr_Value (Type_Low_Bound (Typ));
11944 LB := Expr_Value (Type_Low_Bound (Base_Type (Typ)));
11947 -- Note that the test below is deliberately excluding the
11948 -- largest negative number, since that is a potentially
11949 -- troublesome case (e.g. -2 * x, where the result is the
11950 -- largest negative integer has an overflow with 2 * x).
11952 if Val > LB and then Val <= HB then
11957 -- For the multiplication case, the only case we have to worry
11958 -- about is when (-a)*b is exactly the largest negative number
11959 -- so that -(a*b) can cause overflow. This can only happen if
11960 -- a is a power of 2, and more generally if any operand is a
11961 -- constant that is not a power of 2, then the parentheses
11962 -- cannot affect whether overflow occurs. We only bother to
11963 -- test the left most operand
11965 -- Loop looking at left operands for one that has known value
11968 Opnd_Loop : while Nkind (Opnd) = N_Op_Multiply loop
11969 if Compile_Time_Known_Value (Left_Opnd (Opnd)) then
11970 Lval := UI_Abs (Expr_Value (Left_Opnd (Opnd)));
11972 -- Operand value of 0 or 1 skips warning
11977 -- Otherwise check power of 2, if power of 2, warn, if
11978 -- anything else, skip warning.
11981 while Lval /= 2 loop
11982 if Lval mod 2 = 1 then
11993 -- Keep looking at left operands
11995 Opnd := Left_Opnd (Opnd);
11996 end loop Opnd_Loop;
11998 -- For rem or "/" we can only have a problematic situation
11999 -- if the divisor has a value of minus one or one. Otherwise
12000 -- overflow is impossible (divisor > 1) or we have a case of
12001 -- division by zero in any case.
12003 if Nkind_In (Rorig, N_Op_Divide, N_Op_Rem)
12004 and then Compile_Time_Known_Value (Right_Opnd (Rorig))
12005 and then UI_Abs (Expr_Value (Right_Opnd (Rorig))) /= 1
12010 -- If we fall through warning should be issued
12012 -- Shouldn't we test Warn_On_Questionable_Missing_Parens ???
12015 ("??unary minus expression should be parenthesized here!", N);
12019 end Resolve_Unary_Op;
12021 ----------------------------------
12022 -- Resolve_Unchecked_Expression --
12023 ----------------------------------
12025 procedure Resolve_Unchecked_Expression
12030 Resolve (Expression (N), Typ, Suppress => All_Checks);
12031 Set_Etype (N, Typ);
12032 end Resolve_Unchecked_Expression;
12034 ---------------------------------------
12035 -- Resolve_Unchecked_Type_Conversion --
12036 ---------------------------------------
12038 procedure Resolve_Unchecked_Type_Conversion
12042 pragma Warnings (Off, Typ);
12044 Operand : constant Node_Id := Expression (N);
12045 Opnd_Type : constant Entity_Id := Etype (Operand);
12048 -- Resolve operand using its own type
12050 Resolve (Operand, Opnd_Type);
12052 -- In an inlined context, the unchecked conversion may be applied
12053 -- to a literal, in which case its type is the type of the context.
12054 -- (In other contexts conversions cannot apply to literals).
12057 and then (Opnd_Type = Any_Character or else
12058 Opnd_Type = Any_Integer or else
12059 Opnd_Type = Any_Real)
12061 Set_Etype (Operand, Typ);
12064 Analyze_Dimension (N);
12065 Eval_Unchecked_Conversion (N);
12066 end Resolve_Unchecked_Type_Conversion;
12068 ------------------------------
12069 -- Rewrite_Operator_As_Call --
12070 ------------------------------
12072 procedure Rewrite_Operator_As_Call (N : Node_Id; Nam : Entity_Id) is
12073 Loc : constant Source_Ptr := Sloc (N);
12074 Actuals : constant List_Id := New_List;
12078 if Nkind (N) in N_Binary_Op then
12079 Append (Left_Opnd (N), Actuals);
12082 Append (Right_Opnd (N), Actuals);
12085 Make_Function_Call (Sloc => Loc,
12086 Name => New_Occurrence_Of (Nam, Loc),
12087 Parameter_Associations => Actuals);
12089 Preserve_Comes_From_Source (New_N, N);
12090 Preserve_Comes_From_Source (Name (New_N), N);
12091 Rewrite (N, New_N);
12092 Set_Etype (N, Etype (Nam));
12093 end Rewrite_Operator_As_Call;
12095 ------------------------------
12096 -- Rewrite_Renamed_Operator --
12097 ------------------------------
12099 procedure Rewrite_Renamed_Operator
12104 Nam : constant Name_Id := Chars (Op);
12105 Is_Binary : constant Boolean := Nkind (N) in N_Binary_Op;
12109 -- Do not perform this transformation within a pre/postcondition,
12110 -- because the expression will be reanalyzed, and the transformation
12111 -- might affect the visibility of the operator, e.g. in an instance.
12112 -- Note that fully analyzed and expanded pre/postconditions appear as
12113 -- pragma Check equivalents.
12115 if In_Pre_Post_Condition (N) then
12119 -- Likewise when an expression function is being preanalyzed, since the
12120 -- expression will be reanalyzed as part of the generated body.
12122 if In_Spec_Expression then
12124 S : constant Entity_Id := Current_Scope_No_Loops;
12126 if Ekind (S) = E_Function
12127 and then Nkind (Original_Node (Unit_Declaration_Node (S))) =
12128 N_Expression_Function
12135 -- Rewrite the operator node using the real operator, not its renaming.
12136 -- Exclude user-defined intrinsic operations of the same name, which are
12137 -- treated separately and rewritten as calls.
12139 if Ekind (Op) /= E_Function or else Chars (N) /= Nam then
12140 Op_Node := New_Node (Operator_Kind (Nam, Is_Binary), Sloc (N));
12141 Set_Chars (Op_Node, Nam);
12142 Set_Etype (Op_Node, Etype (N));
12143 Set_Entity (Op_Node, Op);
12144 Set_Right_Opnd (Op_Node, Right_Opnd (N));
12146 -- Indicate that both the original entity and its renaming are
12147 -- referenced at this point.
12149 Generate_Reference (Entity (N), N);
12150 Generate_Reference (Op, N);
12153 Set_Left_Opnd (Op_Node, Left_Opnd (N));
12156 Rewrite (N, Op_Node);
12158 -- If the context type is private, add the appropriate conversions so
12159 -- that the operator is applied to the full view. This is done in the
12160 -- routines that resolve intrinsic operators.
12162 if Is_Intrinsic_Subprogram (Op) and then Is_Private_Type (Typ) then
12172 Resolve_Intrinsic_Operator (N, Typ);
12178 Resolve_Intrinsic_Unary_Operator (N, Typ);
12185 elsif Ekind (Op) = E_Function and then Is_Intrinsic_Subprogram (Op) then
12187 -- Operator renames a user-defined operator of the same name. Use the
12188 -- original operator in the node, which is the one Gigi knows about.
12190 Set_Entity (N, Op);
12191 Set_Is_Overloaded (N, False);
12193 end Rewrite_Renamed_Operator;
12195 -----------------------
12196 -- Set_Slice_Subtype --
12197 -----------------------
12199 -- Build an implicit subtype declaration to represent the type delivered by
12200 -- the slice. This is an abbreviated version of an array subtype. We define
12201 -- an index subtype for the slice, using either the subtype name or the
12202 -- discrete range of the slice. To be consistent with index usage elsewhere
12203 -- we create a list header to hold the single index. This list is not
12204 -- otherwise attached to the syntax tree.
12206 procedure Set_Slice_Subtype (N : Node_Id) is
12207 Loc : constant Source_Ptr := Sloc (N);
12208 Index_List : constant List_Id := New_List;
12210 Index_Subtype : Entity_Id;
12211 Index_Type : Entity_Id;
12212 Slice_Subtype : Entity_Id;
12213 Drange : constant Node_Id := Discrete_Range (N);
12216 Index_Type := Base_Type (Etype (Drange));
12218 if Is_Entity_Name (Drange) then
12219 Index_Subtype := Entity (Drange);
12222 -- We force the evaluation of a range. This is definitely needed in
12223 -- the renamed case, and seems safer to do unconditionally. Note in
12224 -- any case that since we will create and insert an Itype referring
12225 -- to this range, we must make sure any side effect removal actions
12226 -- are inserted before the Itype definition.
12228 if Nkind (Drange) = N_Range then
12229 Force_Evaluation (Low_Bound (Drange));
12230 Force_Evaluation (High_Bound (Drange));
12232 -- If the discrete range is given by a subtype indication, the
12233 -- type of the slice is the base of the subtype mark.
12235 elsif Nkind (Drange) = N_Subtype_Indication then
12237 R : constant Node_Id := Range_Expression (Constraint (Drange));
12239 Index_Type := Base_Type (Entity (Subtype_Mark (Drange)));
12240 Force_Evaluation (Low_Bound (R));
12241 Force_Evaluation (High_Bound (R));
12245 Index_Subtype := Create_Itype (Subtype_Kind (Ekind (Index_Type)), N);
12247 -- Take a new copy of Drange (where bounds have been rewritten to
12248 -- reference side-effect-free names). Using a separate tree ensures
12249 -- that further expansion (e.g. while rewriting a slice assignment
12250 -- into a FOR loop) does not attempt to remove side effects on the
12251 -- bounds again (which would cause the bounds in the index subtype
12252 -- definition to refer to temporaries before they are defined) (the
12253 -- reason is that some names are considered side effect free here
12254 -- for the subtype, but not in the context of a loop iteration
12257 Set_Scalar_Range (Index_Subtype, New_Copy_Tree (Drange));
12258 Set_Parent (Scalar_Range (Index_Subtype), Index_Subtype);
12259 Set_Etype (Index_Subtype, Index_Type);
12260 Set_Size_Info (Index_Subtype, Index_Type);
12261 Set_RM_Size (Index_Subtype, RM_Size (Index_Type));
12262 Set_Is_Constrained (Index_Subtype);
12265 Slice_Subtype := Create_Itype (E_Array_Subtype, N);
12267 Index := New_Occurrence_Of (Index_Subtype, Loc);
12268 Set_Etype (Index, Index_Subtype);
12269 Append (Index, Index_List);
12271 Set_First_Index (Slice_Subtype, Index);
12272 Set_Etype (Slice_Subtype, Base_Type (Etype (N)));
12273 Set_Is_Constrained (Slice_Subtype, True);
12275 Check_Compile_Time_Size (Slice_Subtype);
12277 -- The Etype of the existing Slice node is reset to this slice subtype.
12278 -- Its bounds are obtained from its first index.
12280 Set_Etype (N, Slice_Subtype);
12282 -- For bit-packed slice subtypes, freeze immediately (except in the case
12283 -- of being in a "spec expression" where we never freeze when we first
12284 -- see the expression).
12286 if Is_Bit_Packed_Array (Slice_Subtype) and not In_Spec_Expression then
12287 Freeze_Itype (Slice_Subtype, N);
12289 -- For all other cases insert an itype reference in the slice's actions
12290 -- so that the itype is frozen at the proper place in the tree (i.e. at
12291 -- the point where actions for the slice are analyzed). Note that this
12292 -- is different from freezing the itype immediately, which might be
12293 -- premature (e.g. if the slice is within a transient scope). This needs
12294 -- to be done only if expansion is enabled.
12296 elsif Expander_Active then
12297 Ensure_Defined (Typ => Slice_Subtype, N => N);
12299 end Set_Slice_Subtype;
12301 --------------------------------
12302 -- Set_String_Literal_Subtype --
12303 --------------------------------
12305 procedure Set_String_Literal_Subtype (N : Node_Id; Typ : Entity_Id) is
12306 Loc : constant Source_Ptr := Sloc (N);
12307 Low_Bound : constant Node_Id :=
12308 Type_Low_Bound (Etype (First_Index (Typ)));
12309 Subtype_Id : Entity_Id;
12312 if Nkind (N) /= N_String_Literal then
12316 Subtype_Id := Create_Itype (E_String_Literal_Subtype, N);
12317 Set_String_Literal_Length (Subtype_Id, UI_From_Int
12318 (String_Length (Strval (N))));
12319 Set_Etype (Subtype_Id, Base_Type (Typ));
12320 Set_Is_Constrained (Subtype_Id);
12321 Set_Etype (N, Subtype_Id);
12323 -- The low bound is set from the low bound of the corresponding index
12324 -- type. Note that we do not store the high bound in the string literal
12325 -- subtype, but it can be deduced if necessary from the length and the
12328 if Is_OK_Static_Expression (Low_Bound) then
12329 Set_String_Literal_Low_Bound (Subtype_Id, Low_Bound);
12331 -- If the lower bound is not static we create a range for the string
12332 -- literal, using the index type and the known length of the literal.
12333 -- The index type is not necessarily Positive, so the upper bound is
12334 -- computed as T'Val (T'Pos (Low_Bound) + L - 1).
12338 Index_List : constant List_Id := New_List;
12339 Index_Type : constant Entity_Id := Etype (First_Index (Typ));
12340 High_Bound : constant Node_Id :=
12341 Make_Attribute_Reference (Loc,
12342 Attribute_Name => Name_Val,
12344 New_Occurrence_Of (Index_Type, Loc),
12345 Expressions => New_List (
12348 Make_Attribute_Reference (Loc,
12349 Attribute_Name => Name_Pos,
12351 New_Occurrence_Of (Index_Type, Loc),
12353 New_List (New_Copy_Tree (Low_Bound))),
12355 Make_Integer_Literal (Loc,
12356 String_Length (Strval (N)) - 1))));
12358 Array_Subtype : Entity_Id;
12361 Index_Subtype : Entity_Id;
12364 if Is_Integer_Type (Index_Type) then
12365 Set_String_Literal_Low_Bound
12366 (Subtype_Id, Make_Integer_Literal (Loc, 1));
12369 -- If the index type is an enumeration type, build bounds
12370 -- expression with attributes.
12372 Set_String_Literal_Low_Bound
12374 Make_Attribute_Reference (Loc,
12375 Attribute_Name => Name_First,
12377 New_Occurrence_Of (Base_Type (Index_Type), Loc)));
12378 Set_Etype (String_Literal_Low_Bound (Subtype_Id), Index_Type);
12381 Analyze_And_Resolve (String_Literal_Low_Bound (Subtype_Id));
12383 -- Build bona fide subtype for the string, and wrap it in an
12384 -- unchecked conversion, because the back end expects the
12385 -- String_Literal_Subtype to have a static lower bound.
12388 Create_Itype (Subtype_Kind (Ekind (Index_Type)), N);
12389 Drange := Make_Range (Loc, New_Copy_Tree (Low_Bound), High_Bound);
12390 Set_Scalar_Range (Index_Subtype, Drange);
12391 Set_Parent (Drange, N);
12392 Analyze_And_Resolve (Drange, Index_Type);
12394 -- In this context, the Index_Type may already have a constraint,
12395 -- so use common base type on string subtype. The base type may
12396 -- be used when generating attributes of the string, for example
12397 -- in the context of a slice assignment.
12399 Set_Etype (Index_Subtype, Base_Type (Index_Type));
12400 Set_Size_Info (Index_Subtype, Index_Type);
12401 Set_RM_Size (Index_Subtype, RM_Size (Index_Type));
12403 Array_Subtype := Create_Itype (E_Array_Subtype, N);
12405 Index := New_Occurrence_Of (Index_Subtype, Loc);
12406 Set_Etype (Index, Index_Subtype);
12407 Append (Index, Index_List);
12409 Set_First_Index (Array_Subtype, Index);
12410 Set_Etype (Array_Subtype, Base_Type (Typ));
12411 Set_Is_Constrained (Array_Subtype, True);
12414 Make_Unchecked_Type_Conversion (Loc,
12415 Subtype_Mark => New_Occurrence_Of (Array_Subtype, Loc),
12416 Expression => Relocate_Node (N)));
12417 Set_Etype (N, Array_Subtype);
12420 end Set_String_Literal_Subtype;
12422 ------------------------------
12423 -- Simplify_Type_Conversion --
12424 ------------------------------
12426 procedure Simplify_Type_Conversion (N : Node_Id) is
12428 if Nkind (N) = N_Type_Conversion then
12430 Operand : constant Node_Id := Expression (N);
12431 Target_Typ : constant Entity_Id := Etype (N);
12432 Opnd_Typ : constant Entity_Id := Etype (Operand);
12435 -- Special processing if the conversion is the expression of a
12436 -- Rounding or Truncation attribute reference. In this case we
12439 -- ityp (ftyp'Rounding (x)) or ityp (ftyp'Truncation (x))
12445 -- with the Float_Truncate flag set to False or True respectively,
12446 -- which is more efficient. We reuse Rounding for Machine_Rounding
12447 -- as System.Fat_Gen, which is a permissible behavior.
12449 if Is_Floating_Point_Type (Opnd_Typ)
12451 (Is_Integer_Type (Target_Typ)
12452 or else (Is_Fixed_Point_Type (Target_Typ)
12453 and then Conversion_OK (N)))
12454 and then Nkind (Operand) = N_Attribute_Reference
12455 and then Nam_In (Attribute_Name (Operand), Name_Rounding,
12456 Name_Machine_Rounding,
12460 Truncate : constant Boolean :=
12461 Attribute_Name (Operand) = Name_Truncation;
12464 Relocate_Node (First (Expressions (Operand))));
12465 Set_Float_Truncate (N, Truncate);
12470 end Simplify_Type_Conversion;
12472 -----------------------------
12473 -- Unique_Fixed_Point_Type --
12474 -----------------------------
12476 function Unique_Fixed_Point_Type (N : Node_Id) return Entity_Id is
12477 procedure Fixed_Point_Error (T1 : Entity_Id; T2 : Entity_Id);
12478 -- Give error messages for true ambiguity. Messages are posted on node
12479 -- N, and entities T1, T2 are the possible interpretations.
12481 -----------------------
12482 -- Fixed_Point_Error --
12483 -----------------------
12485 procedure Fixed_Point_Error (T1 : Entity_Id; T2 : Entity_Id) is
12487 Error_Msg_N ("ambiguous universal_fixed_expression", N);
12488 Error_Msg_NE ("\\possible interpretation as}", N, T1);
12489 Error_Msg_NE ("\\possible interpretation as}", N, T2);
12490 end Fixed_Point_Error;
12500 -- Start of processing for Unique_Fixed_Point_Type
12503 -- The operations on Duration are visible, so Duration is always a
12504 -- possible interpretation.
12506 T1 := Standard_Duration;
12508 -- Look for fixed-point types in enclosing scopes
12510 Scop := Current_Scope;
12511 while Scop /= Standard_Standard loop
12512 T2 := First_Entity (Scop);
12513 while Present (T2) loop
12514 if Is_Fixed_Point_Type (T2)
12515 and then Current_Entity (T2) = T2
12516 and then Scope (Base_Type (T2)) = Scop
12518 if Present (T1) then
12519 Fixed_Point_Error (T1, T2);
12529 Scop := Scope (Scop);
12532 -- Look for visible fixed type declarations in the context
12534 Item := First (Context_Items (Cunit (Current_Sem_Unit)));
12535 while Present (Item) loop
12536 if Nkind (Item) = N_With_Clause then
12537 Scop := Entity (Name (Item));
12538 T2 := First_Entity (Scop);
12539 while Present (T2) loop
12540 if Is_Fixed_Point_Type (T2)
12541 and then Scope (Base_Type (T2)) = Scop
12542 and then (Is_Potentially_Use_Visible (T2) or else In_Use (T2))
12544 if Present (T1) then
12545 Fixed_Point_Error (T1, T2);
12559 if Nkind (N) = N_Real_Literal then
12560 Error_Msg_NE ("??real literal interpreted as }!", N, T1);
12563 -- When the context is a type conversion, issue the warning on the
12564 -- expression of the conversion because it is the actual operation.
12566 if Nkind_In (N, N_Type_Conversion, N_Unchecked_Type_Conversion) then
12567 ErrN := Expression (N);
12573 ("??universal_fixed expression interpreted as }!", ErrN, T1);
12577 end Unique_Fixed_Point_Type;
12579 ----------------------
12580 -- Valid_Conversion --
12581 ----------------------
12583 function Valid_Conversion
12585 Target : Entity_Id;
12587 Report_Errs : Boolean := True) return Boolean
12589 Target_Type : constant Entity_Id := Base_Type (Target);
12590 Opnd_Type : Entity_Id := Etype (Operand);
12591 Inc_Ancestor : Entity_Id;
12593 function Conversion_Check
12595 Msg : String) return Boolean;
12596 -- Little routine to post Msg if Valid is False, returns Valid value
12598 procedure Conversion_Error_N (Msg : String; N : Node_Or_Entity_Id);
12599 -- If Report_Errs, then calls Errout.Error_Msg_N with its arguments
12601 procedure Conversion_Error_NE
12603 N : Node_Or_Entity_Id;
12604 E : Node_Or_Entity_Id);
12605 -- If Report_Errs, then calls Errout.Error_Msg_NE with its arguments
12607 function In_Instance_Code return Boolean;
12608 -- Return True if expression is within an instance but is not in one of
12609 -- the actuals of the instantiation. Type conversions within an instance
12610 -- are not rechecked because type visbility may lead to spurious errors,
12611 -- but conversions in an actual for a formal object must be checked.
12613 function Valid_Tagged_Conversion
12614 (Target_Type : Entity_Id;
12615 Opnd_Type : Entity_Id) return Boolean;
12616 -- Specifically test for validity of tagged conversions
12618 function Valid_Array_Conversion return Boolean;
12619 -- Check index and component conformance, and accessibility levels if
12620 -- the component types are anonymous access types (Ada 2005).
12622 ----------------------
12623 -- Conversion_Check --
12624 ----------------------
12626 function Conversion_Check
12628 Msg : String) return Boolean
12633 -- A generic unit has already been analyzed and we have verified
12634 -- that a particular conversion is OK in that context. Since the
12635 -- instance is reanalyzed without relying on the relationships
12636 -- established during the analysis of the generic, it is possible
12637 -- to end up with inconsistent views of private types. Do not emit
12638 -- the error message in such cases. The rest of the machinery in
12639 -- Valid_Conversion still ensures the proper compatibility of
12640 -- target and operand types.
12642 and then not In_Instance_Code
12644 Conversion_Error_N (Msg, Operand);
12648 end Conversion_Check;
12650 ------------------------
12651 -- Conversion_Error_N --
12652 ------------------------
12654 procedure Conversion_Error_N (Msg : String; N : Node_Or_Entity_Id) is
12656 if Report_Errs then
12657 Error_Msg_N (Msg, N);
12659 end Conversion_Error_N;
12661 -------------------------
12662 -- Conversion_Error_NE --
12663 -------------------------
12665 procedure Conversion_Error_NE
12667 N : Node_Or_Entity_Id;
12668 E : Node_Or_Entity_Id)
12671 if Report_Errs then
12672 Error_Msg_NE (Msg, N, E);
12674 end Conversion_Error_NE;
12676 ----------------------
12677 -- In_Instance_Code --
12678 ----------------------
12680 function In_Instance_Code return Boolean is
12684 if not In_Instance then
12689 while Present (Par) loop
12691 -- The expression is part of an actual object if it appears in
12692 -- the generated object declaration in the instance.
12694 if Nkind (Par) = N_Object_Declaration
12695 and then Present (Corresponding_Generic_Association (Par))
12701 Nkind (Par) in N_Statement_Other_Than_Procedure_Call
12702 or else Nkind (Par) in N_Subprogram_Call
12703 or else Nkind (Par) in N_Declaration;
12706 Par := Parent (Par);
12709 -- Otherwise the expression appears within the instantiated unit
12713 end In_Instance_Code;
12715 ----------------------------
12716 -- Valid_Array_Conversion --
12717 ----------------------------
12719 function Valid_Array_Conversion return Boolean is
12720 Opnd_Comp_Type : constant Entity_Id := Component_Type (Opnd_Type);
12721 Opnd_Comp_Base : constant Entity_Id := Base_Type (Opnd_Comp_Type);
12723 Opnd_Index : Node_Id;
12724 Opnd_Index_Type : Entity_Id;
12726 Target_Comp_Type : constant Entity_Id :=
12727 Component_Type (Target_Type);
12728 Target_Comp_Base : constant Entity_Id :=
12729 Base_Type (Target_Comp_Type);
12731 Target_Index : Node_Id;
12732 Target_Index_Type : Entity_Id;
12735 -- Error if wrong number of dimensions
12738 Number_Dimensions (Target_Type) /= Number_Dimensions (Opnd_Type)
12741 ("incompatible number of dimensions for conversion", Operand);
12744 -- Number of dimensions matches
12747 -- Loop through indexes of the two arrays
12749 Target_Index := First_Index (Target_Type);
12750 Opnd_Index := First_Index (Opnd_Type);
12751 while Present (Target_Index) and then Present (Opnd_Index) loop
12752 Target_Index_Type := Etype (Target_Index);
12753 Opnd_Index_Type := Etype (Opnd_Index);
12755 -- Error if index types are incompatible
12757 if not (Is_Integer_Type (Target_Index_Type)
12758 and then Is_Integer_Type (Opnd_Index_Type))
12759 and then (Root_Type (Target_Index_Type)
12760 /= Root_Type (Opnd_Index_Type))
12763 ("incompatible index types for array conversion",
12768 Next_Index (Target_Index);
12769 Next_Index (Opnd_Index);
12772 -- If component types have same base type, all set
12774 if Target_Comp_Base = Opnd_Comp_Base then
12777 -- Here if base types of components are not the same. The only
12778 -- time this is allowed is if we have anonymous access types.
12780 -- The conversion of arrays of anonymous access types can lead
12781 -- to dangling pointers. AI-392 formalizes the accessibility
12782 -- checks that must be applied to such conversions to prevent
12783 -- out-of-scope references.
12786 (Target_Comp_Base, E_Anonymous_Access_Type,
12787 E_Anonymous_Access_Subprogram_Type)
12788 and then Ekind (Opnd_Comp_Base) = Ekind (Target_Comp_Base)
12790 Subtypes_Statically_Match (Target_Comp_Type, Opnd_Comp_Type)
12792 if Type_Access_Level (Target_Type) <
12793 Deepest_Type_Access_Level (Opnd_Type)
12795 if In_Instance_Body then
12796 Error_Msg_Warn := SPARK_Mode /= On;
12798 ("source array type has deeper accessibility "
12799 & "level than target<<", Operand);
12800 Conversion_Error_N ("\Program_Error [<<", Operand);
12802 Make_Raise_Program_Error (Sloc (N),
12803 Reason => PE_Accessibility_Check_Failed));
12804 Set_Etype (N, Target_Type);
12807 -- Conversion not allowed because of accessibility levels
12811 ("source array type has deeper accessibility "
12812 & "level than target", Operand);
12820 -- All other cases where component base types do not match
12824 ("incompatible component types for array conversion",
12829 -- Check that component subtypes statically match. For numeric
12830 -- types this means that both must be either constrained or
12831 -- unconstrained. For enumeration types the bounds must match.
12832 -- All of this is checked in Subtypes_Statically_Match.
12834 if not Subtypes_Statically_Match
12835 (Target_Comp_Type, Opnd_Comp_Type)
12838 ("component subtypes must statically match", Operand);
12844 end Valid_Array_Conversion;
12846 -----------------------------
12847 -- Valid_Tagged_Conversion --
12848 -----------------------------
12850 function Valid_Tagged_Conversion
12851 (Target_Type : Entity_Id;
12852 Opnd_Type : Entity_Id) return Boolean
12855 -- Upward conversions are allowed (RM 4.6(22))
12857 if Covers (Target_Type, Opnd_Type)
12858 or else Is_Ancestor (Target_Type, Opnd_Type)
12862 -- Downward conversion are allowed if the operand is class-wide
12865 elsif Is_Class_Wide_Type (Opnd_Type)
12866 and then Covers (Opnd_Type, Target_Type)
12870 elsif Covers (Opnd_Type, Target_Type)
12871 or else Is_Ancestor (Opnd_Type, Target_Type)
12874 Conversion_Check (False,
12875 "downward conversion of tagged objects not allowed");
12877 -- Ada 2005 (AI-251): The conversion to/from interface types is
12878 -- always valid. The types involved may be class-wide (sub)types.
12880 elsif Is_Interface (Etype (Base_Type (Target_Type)))
12881 or else Is_Interface (Etype (Base_Type (Opnd_Type)))
12885 -- If the operand is a class-wide type obtained through a limited_
12886 -- with clause, and the context includes the nonlimited view, use
12887 -- it to determine whether the conversion is legal.
12889 elsif Is_Class_Wide_Type (Opnd_Type)
12890 and then From_Limited_With (Opnd_Type)
12891 and then Present (Non_Limited_View (Etype (Opnd_Type)))
12892 and then Is_Interface (Non_Limited_View (Etype (Opnd_Type)))
12896 elsif Is_Access_Type (Opnd_Type)
12897 and then Is_Interface (Directly_Designated_Type (Opnd_Type))
12902 Conversion_Error_NE
12903 ("invalid tagged conversion, not compatible with}",
12904 N, First_Subtype (Opnd_Type));
12907 end Valid_Tagged_Conversion;
12909 -- Start of processing for Valid_Conversion
12912 Check_Parameterless_Call (Operand);
12914 if Is_Overloaded (Operand) then
12924 -- Remove procedure calls, which syntactically cannot appear in
12925 -- this context, but which cannot be removed by type checking,
12926 -- because the context does not impose a type.
12928 -- The node may be labelled overloaded, but still contain only one
12929 -- interpretation because others were discarded earlier. If this
12930 -- is the case, retain the single interpretation if legal.
12932 Get_First_Interp (Operand, I, It);
12933 Opnd_Type := It.Typ;
12934 Get_Next_Interp (I, It);
12936 if Present (It.Typ)
12937 and then Opnd_Type /= Standard_Void_Type
12939 -- More than one candidate interpretation is available
12941 Get_First_Interp (Operand, I, It);
12942 while Present (It.Typ) loop
12943 if It.Typ = Standard_Void_Type then
12947 -- When compiling for a system where Address is of a visible
12948 -- integer type, spurious ambiguities can be produced when
12949 -- arithmetic operations have a literal operand and return
12950 -- System.Address or a descendant of it. These ambiguities
12951 -- are usually resolved by the context, but for conversions
12952 -- there is no context type and the removal of the spurious
12953 -- operations must be done explicitly here.
12955 if not Address_Is_Private
12956 and then Is_Descendant_Of_Address (It.Typ)
12961 Get_Next_Interp (I, It);
12965 Get_First_Interp (Operand, I, It);
12969 if No (It.Typ) then
12970 Conversion_Error_N ("illegal operand in conversion", Operand);
12974 Get_Next_Interp (I, It);
12976 if Present (It.Typ) then
12979 It1 := Disambiguate (Operand, I1, I, Any_Type);
12981 if It1 = No_Interp then
12983 ("ambiguous operand in conversion", Operand);
12985 -- If the interpretation involves a standard operator, use
12986 -- the location of the type, which may be user-defined.
12988 if Sloc (It.Nam) = Standard_Location then
12989 Error_Msg_Sloc := Sloc (It.Typ);
12991 Error_Msg_Sloc := Sloc (It.Nam);
12994 Conversion_Error_N -- CODEFIX
12995 ("\\possible interpretation#!", Operand);
12997 if Sloc (N1) = Standard_Location then
12998 Error_Msg_Sloc := Sloc (T1);
13000 Error_Msg_Sloc := Sloc (N1);
13003 Conversion_Error_N -- CODEFIX
13004 ("\\possible interpretation#!", Operand);
13010 Set_Etype (Operand, It1.Typ);
13011 Opnd_Type := It1.Typ;
13015 -- Deal with conversion of integer type to address if the pragma
13016 -- Allow_Integer_Address is in effect. We convert the conversion to
13017 -- an unchecked conversion in this case and we are all done.
13019 if Address_Integer_Convert_OK (Opnd_Type, Target_Type) then
13020 Rewrite (N, Unchecked_Convert_To (Target_Type, Expression (N)));
13021 Analyze_And_Resolve (N, Target_Type);
13025 -- If we are within a child unit, check whether the type of the
13026 -- expression has an ancestor in a parent unit, in which case it
13027 -- belongs to its derivation class even if the ancestor is private.
13028 -- See RM 7.3.1 (5.2/3).
13030 Inc_Ancestor := Get_Incomplete_View_Of_Ancestor (Opnd_Type);
13034 if Is_Numeric_Type (Target_Type) then
13036 -- A universal fixed expression can be converted to any numeric type
13038 if Opnd_Type = Universal_Fixed then
13041 -- Also no need to check when in an instance or inlined body, because
13042 -- the legality has been established when the template was analyzed.
13043 -- Furthermore, numeric conversions may occur where only a private
13044 -- view of the operand type is visible at the instantiation point.
13045 -- This results in a spurious error if we check that the operand type
13046 -- is a numeric type.
13048 -- Note: in a previous version of this unit, the following tests were
13049 -- applied only for generated code (Comes_From_Source set to False),
13050 -- but in fact the test is required for source code as well, since
13051 -- this situation can arise in source code.
13053 elsif In_Instance_Code or else In_Inlined_Body then
13056 -- Otherwise we need the conversion check
13059 return Conversion_Check
13060 (Is_Numeric_Type (Opnd_Type)
13062 (Present (Inc_Ancestor)
13063 and then Is_Numeric_Type (Inc_Ancestor)),
13064 "illegal operand for numeric conversion");
13069 elsif Is_Array_Type (Target_Type) then
13070 if not Is_Array_Type (Opnd_Type)
13071 or else Opnd_Type = Any_Composite
13072 or else Opnd_Type = Any_String
13075 ("illegal operand for array conversion", Operand);
13079 return Valid_Array_Conversion;
13082 -- Ada 2005 (AI-251): Internally generated conversions of access to
13083 -- interface types added to force the displacement of the pointer to
13084 -- reference the corresponding dispatch table.
13086 elsif not Comes_From_Source (N)
13087 and then Is_Access_Type (Target_Type)
13088 and then Is_Interface (Designated_Type (Target_Type))
13092 -- Ada 2005 (AI-251): Anonymous access types where target references an
13095 elsif Is_Access_Type (Opnd_Type)
13096 and then Ekind_In (Target_Type, E_General_Access_Type,
13097 E_Anonymous_Access_Type)
13098 and then Is_Interface (Directly_Designated_Type (Target_Type))
13100 -- Check the static accessibility rule of 4.6(17). Note that the
13101 -- check is not enforced when within an instance body, since the
13102 -- RM requires such cases to be caught at run time.
13104 -- If the operand is a rewriting of an allocator no check is needed
13105 -- because there are no accessibility issues.
13107 if Nkind (Original_Node (N)) = N_Allocator then
13110 elsif Ekind (Target_Type) /= E_Anonymous_Access_Type then
13111 if Type_Access_Level (Opnd_Type) >
13112 Deepest_Type_Access_Level (Target_Type)
13114 -- In an instance, this is a run-time check, but one we know
13115 -- will fail, so generate an appropriate warning. The raise
13116 -- will be generated by Expand_N_Type_Conversion.
13118 if In_Instance_Body then
13119 Error_Msg_Warn := SPARK_Mode /= On;
13121 ("cannot convert local pointer to non-local access type<<",
13123 Conversion_Error_N ("\Program_Error [<<", Operand);
13127 ("cannot convert local pointer to non-local access type",
13132 -- Special accessibility checks are needed in the case of access
13133 -- discriminants declared for a limited type.
13135 elsif Ekind (Opnd_Type) = E_Anonymous_Access_Type
13136 and then not Is_Local_Anonymous_Access (Opnd_Type)
13138 -- When the operand is a selected access discriminant the check
13139 -- needs to be made against the level of the object denoted by
13140 -- the prefix of the selected name (Object_Access_Level handles
13141 -- checking the prefix of the operand for this case).
13143 if Nkind (Operand) = N_Selected_Component
13144 and then Object_Access_Level (Operand) >
13145 Deepest_Type_Access_Level (Target_Type)
13147 -- In an instance, this is a run-time check, but one we know
13148 -- will fail, so generate an appropriate warning. The raise
13149 -- will be generated by Expand_N_Type_Conversion.
13151 if In_Instance_Body then
13152 Error_Msg_Warn := SPARK_Mode /= On;
13154 ("cannot convert access discriminant to non-local "
13155 & "access type<<", Operand);
13156 Conversion_Error_N ("\Program_Error [<<", Operand);
13158 -- Real error if not in instance body
13162 ("cannot convert access discriminant to non-local "
13163 & "access type", Operand);
13168 -- The case of a reference to an access discriminant from
13169 -- within a limited type declaration (which will appear as
13170 -- a discriminal) is always illegal because the level of the
13171 -- discriminant is considered to be deeper than any (nameable)
13174 if Is_Entity_Name (Operand)
13175 and then not Is_Local_Anonymous_Access (Opnd_Type)
13177 Ekind_In (Entity (Operand), E_In_Parameter, E_Constant)
13178 and then Present (Discriminal_Link (Entity (Operand)))
13181 ("discriminant has deeper accessibility level than target",
13190 -- General and anonymous access types
13192 elsif Ekind_In (Target_Type, E_General_Access_Type,
13193 E_Anonymous_Access_Type)
13196 (Is_Access_Type (Opnd_Type)
13198 Ekind_In (Opnd_Type, E_Access_Subprogram_Type,
13199 E_Access_Protected_Subprogram_Type),
13200 "must be an access-to-object type")
13202 if Is_Access_Constant (Opnd_Type)
13203 and then not Is_Access_Constant (Target_Type)
13206 ("access-to-constant operand type not allowed", Operand);
13210 -- Check the static accessibility rule of 4.6(17). Note that the
13211 -- check is not enforced when within an instance body, since the RM
13212 -- requires such cases to be caught at run time.
13214 if Ekind (Target_Type) /= E_Anonymous_Access_Type
13215 or else Is_Local_Anonymous_Access (Target_Type)
13216 or else Nkind (Associated_Node_For_Itype (Target_Type)) =
13217 N_Object_Declaration
13219 -- Ada 2012 (AI05-0149): Perform legality checking on implicit
13220 -- conversions from an anonymous access type to a named general
13221 -- access type. Such conversions are not allowed in the case of
13222 -- access parameters and stand-alone objects of an anonymous
13223 -- access type. The implicit conversion case is recognized by
13224 -- testing that Comes_From_Source is False and that it's been
13225 -- rewritten. The Comes_From_Source test isn't sufficient because
13226 -- nodes in inlined calls to predefined library routines can have
13227 -- Comes_From_Source set to False. (Is there a better way to test
13228 -- for implicit conversions???)
13230 if Ada_Version >= Ada_2012
13231 and then not Comes_From_Source (N)
13232 and then Is_Rewrite_Substitution (N)
13233 and then Ekind (Target_Type) = E_General_Access_Type
13234 and then Ekind (Opnd_Type) = E_Anonymous_Access_Type
13236 if Is_Itype (Opnd_Type) then
13238 -- Implicit conversions aren't allowed for objects of an
13239 -- anonymous access type, since such objects have nonstatic
13240 -- levels in Ada 2012.
13242 if Nkind (Associated_Node_For_Itype (Opnd_Type)) =
13243 N_Object_Declaration
13246 ("implicit conversion of stand-alone anonymous "
13247 & "access object not allowed", Operand);
13250 -- Implicit conversions aren't allowed for anonymous access
13251 -- parameters. The "not Is_Local_Anonymous_Access_Type" test
13252 -- is done to exclude anonymous access results.
13254 elsif not Is_Local_Anonymous_Access (Opnd_Type)
13255 and then Nkind_In (Associated_Node_For_Itype (Opnd_Type),
13256 N_Function_Specification,
13257 N_Procedure_Specification)
13260 ("implicit conversion of anonymous access formal "
13261 & "not allowed", Operand);
13264 -- This is a case where there's an enclosing object whose
13265 -- to which the "statically deeper than" relationship does
13266 -- not apply (such as an access discriminant selected from
13267 -- a dereference of an access parameter).
13269 elsif Object_Access_Level (Operand)
13270 = Scope_Depth (Standard_Standard)
13273 ("implicit conversion of anonymous access value "
13274 & "not allowed", Operand);
13277 -- In other cases, the level of the operand's type must be
13278 -- statically less deep than that of the target type, else
13279 -- implicit conversion is disallowed (by RM12-8.6(27.1/3)).
13281 elsif Type_Access_Level (Opnd_Type) >
13282 Deepest_Type_Access_Level (Target_Type)
13285 ("implicit conversion of anonymous access value "
13286 & "violates accessibility", Operand);
13291 elsif Type_Access_Level (Opnd_Type) >
13292 Deepest_Type_Access_Level (Target_Type)
13294 -- In an instance, this is a run-time check, but one we know
13295 -- will fail, so generate an appropriate warning. The raise
13296 -- will be generated by Expand_N_Type_Conversion.
13298 if In_Instance_Body then
13299 Error_Msg_Warn := SPARK_Mode /= On;
13301 ("cannot convert local pointer to non-local access type<<",
13303 Conversion_Error_N ("\Program_Error [<<", Operand);
13305 -- If not in an instance body, this is a real error
13308 -- Avoid generation of spurious error message
13310 if not Error_Posted (N) then
13312 ("cannot convert local pointer to non-local access type",
13319 -- Special accessibility checks are needed in the case of access
13320 -- discriminants declared for a limited type.
13322 elsif Ekind (Opnd_Type) = E_Anonymous_Access_Type
13323 and then not Is_Local_Anonymous_Access (Opnd_Type)
13325 -- When the operand is a selected access discriminant the check
13326 -- needs to be made against the level of the object denoted by
13327 -- the prefix of the selected name (Object_Access_Level handles
13328 -- checking the prefix of the operand for this case).
13330 if Nkind (Operand) = N_Selected_Component
13331 and then Object_Access_Level (Operand) >
13332 Deepest_Type_Access_Level (Target_Type)
13334 -- In an instance, this is a run-time check, but one we know
13335 -- will fail, so generate an appropriate warning. The raise
13336 -- will be generated by Expand_N_Type_Conversion.
13338 if In_Instance_Body then
13339 Error_Msg_Warn := SPARK_Mode /= On;
13341 ("cannot convert access discriminant to non-local "
13342 & "access type<<", Operand);
13343 Conversion_Error_N ("\Program_Error [<<", Operand);
13345 -- If not in an instance body, this is a real error
13349 ("cannot convert access discriminant to non-local "
13350 & "access type", Operand);
13355 -- The case of a reference to an access discriminant from
13356 -- within a limited type declaration (which will appear as
13357 -- a discriminal) is always illegal because the level of the
13358 -- discriminant is considered to be deeper than any (nameable)
13361 if Is_Entity_Name (Operand)
13363 Ekind_In (Entity (Operand), E_In_Parameter, E_Constant)
13364 and then Present (Discriminal_Link (Entity (Operand)))
13367 ("discriminant has deeper accessibility level than target",
13374 -- In the presence of limited_with clauses we have to use nonlimited
13375 -- views, if available.
13377 Check_Limited : declare
13378 function Full_Designated_Type (T : Entity_Id) return Entity_Id;
13379 -- Helper function to handle limited views
13381 --------------------------
13382 -- Full_Designated_Type --
13383 --------------------------
13385 function Full_Designated_Type (T : Entity_Id) return Entity_Id is
13386 Desig : constant Entity_Id := Designated_Type (T);
13389 -- Handle the limited view of a type
13391 if From_Limited_With (Desig)
13392 and then Has_Non_Limited_View (Desig)
13394 return Available_View (Desig);
13398 end Full_Designated_Type;
13400 -- Local Declarations
13402 Target : constant Entity_Id := Full_Designated_Type (Target_Type);
13403 Opnd : constant Entity_Id := Full_Designated_Type (Opnd_Type);
13405 Same_Base : constant Boolean :=
13406 Base_Type (Target) = Base_Type (Opnd);
13408 -- Start of processing for Check_Limited
13411 if Is_Tagged_Type (Target) then
13412 return Valid_Tagged_Conversion (Target, Opnd);
13415 if not Same_Base then
13416 Conversion_Error_NE
13417 ("target designated type not compatible with }",
13418 N, Base_Type (Opnd));
13421 -- Ada 2005 AI-384: legality rule is symmetric in both
13422 -- designated types. The conversion is legal (with possible
13423 -- constraint check) if either designated type is
13426 elsif Subtypes_Statically_Match (Target, Opnd)
13428 (Has_Discriminants (Target)
13430 (not Is_Constrained (Opnd)
13431 or else not Is_Constrained (Target)))
13433 -- Special case, if Value_Size has been used to make the
13434 -- sizes different, the conversion is not allowed even
13435 -- though the subtypes statically match.
13437 if Known_Static_RM_Size (Target)
13438 and then Known_Static_RM_Size (Opnd)
13439 and then RM_Size (Target) /= RM_Size (Opnd)
13441 Conversion_Error_NE
13442 ("target designated subtype not compatible with }",
13444 Conversion_Error_NE
13445 ("\because sizes of the two designated subtypes differ",
13449 -- Normal case where conversion is allowed
13457 ("target designated subtype not compatible with }",
13464 -- Access to subprogram types. If the operand is an access parameter,
13465 -- the type has a deeper accessibility that any master, and cannot be
13466 -- assigned. We must make an exception if the conversion is part of an
13467 -- assignment and the target is the return object of an extended return
13468 -- statement, because in that case the accessibility check takes place
13469 -- after the return.
13471 elsif Is_Access_Subprogram_Type (Target_Type)
13473 -- Note: this test of Opnd_Type is there to prevent entering this
13474 -- branch in the case of a remote access to subprogram type, which
13475 -- is internally represented as an E_Record_Type.
13477 and then Is_Access_Type (Opnd_Type)
13479 if Ekind (Base_Type (Opnd_Type)) = E_Anonymous_Access_Subprogram_Type
13480 and then Is_Entity_Name (Operand)
13481 and then Ekind (Entity (Operand)) = E_In_Parameter
13483 (Nkind (Parent (N)) /= N_Assignment_Statement
13484 or else not Is_Entity_Name (Name (Parent (N)))
13485 or else not Is_Return_Object (Entity (Name (Parent (N)))))
13488 ("illegal attempt to store anonymous access to subprogram",
13491 ("\value has deeper accessibility than any master "
13492 & "(RM 3.10.2 (13))",
13496 ("\use named access type for& instead of access parameter",
13497 Operand, Entity (Operand));
13500 -- Check that the designated types are subtype conformant
13502 Check_Subtype_Conformant (New_Id => Designated_Type (Target_Type),
13503 Old_Id => Designated_Type (Opnd_Type),
13506 -- Check the static accessibility rule of 4.6(20)
13508 if Type_Access_Level (Opnd_Type) >
13509 Deepest_Type_Access_Level (Target_Type)
13512 ("operand type has deeper accessibility level than target",
13515 -- Check that if the operand type is declared in a generic body,
13516 -- then the target type must be declared within that same body
13517 -- (enforces last sentence of 4.6(20)).
13519 elsif Present (Enclosing_Generic_Body (Opnd_Type)) then
13521 O_Gen : constant Node_Id :=
13522 Enclosing_Generic_Body (Opnd_Type);
13527 T_Gen := Enclosing_Generic_Body (Target_Type);
13528 while Present (T_Gen) and then T_Gen /= O_Gen loop
13529 T_Gen := Enclosing_Generic_Body (T_Gen);
13532 if T_Gen /= O_Gen then
13534 ("target type must be declared in same generic body "
13535 & "as operand type", N);
13542 -- Remote access to subprogram types
13544 elsif Is_Remote_Access_To_Subprogram_Type (Target_Type)
13545 and then Is_Remote_Access_To_Subprogram_Type (Opnd_Type)
13547 -- It is valid to convert from one RAS type to another provided
13548 -- that their specification statically match.
13550 -- Note: at this point, remote access to subprogram types have been
13551 -- expanded to their E_Record_Type representation, and we need to
13552 -- go back to the original access type definition using the
13553 -- Corresponding_Remote_Type attribute in order to check that the
13554 -- designated profiles match.
13556 pragma Assert (Ekind (Target_Type) = E_Record_Type);
13557 pragma Assert (Ekind (Opnd_Type) = E_Record_Type);
13559 Check_Subtype_Conformant
13561 Designated_Type (Corresponding_Remote_Type (Target_Type)),
13563 Designated_Type (Corresponding_Remote_Type (Opnd_Type)),
13568 -- If it was legal in the generic, it's legal in the instance
13570 elsif In_Instance_Body then
13573 -- If both are tagged types, check legality of view conversions
13575 elsif Is_Tagged_Type (Target_Type)
13577 Is_Tagged_Type (Opnd_Type)
13579 return Valid_Tagged_Conversion (Target_Type, Opnd_Type);
13581 -- Types derived from the same root type are convertible
13583 elsif Root_Type (Target_Type) = Root_Type (Opnd_Type) then
13586 -- In an instance or an inlined body, there may be inconsistent views of
13587 -- the same type, or of types derived from a common root.
13589 elsif (In_Instance or In_Inlined_Body)
13591 Root_Type (Underlying_Type (Target_Type)) =
13592 Root_Type (Underlying_Type (Opnd_Type))
13596 -- Special check for common access type error case
13598 elsif Ekind (Target_Type) = E_Access_Type
13599 and then Is_Access_Type (Opnd_Type)
13601 Conversion_Error_N ("target type must be general access type!", N);
13602 Conversion_Error_NE -- CODEFIX
13603 ("add ALL to }!", N, Target_Type);
13606 -- Here we have a real conversion error
13609 -- Check for missing regular with_clause when only a limited view of
13610 -- target is available.
13612 if From_Limited_With (Opnd_Type) and then In_Package_Body then
13613 Conversion_Error_NE
13614 ("invalid conversion, not compatible with limited view of }",
13616 Conversion_Error_NE
13617 ("\add with_clause for& to current unit!", N, Scope (Opnd_Type));
13619 elsif Is_Access_Type (Opnd_Type)
13620 and then From_Limited_With (Designated_Type (Opnd_Type))
13621 and then In_Package_Body
13623 Conversion_Error_NE
13624 ("invalid conversion, not compatible with }", N, Opnd_Type);
13625 Conversion_Error_NE
13626 ("\add with_clause for& to current unit!",
13627 N, Scope (Designated_Type (Opnd_Type)));
13630 Conversion_Error_NE
13631 ("invalid conversion, not compatible with }", N, Opnd_Type);
13636 end Valid_Conversion;