1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2020, 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 Types
; use Types
;
29 type Conformance_Type
is
30 (Type_Conformant
, Mode_Conformant
, Subtype_Conformant
, Fully_Conformant
);
31 pragma Ordered
(Conformance_Type
);
32 -- Conformance type used in conformance checks between specs and bodies,
33 -- and for overriding. The literals match the RM definitions of the
34 -- corresponding terms. This is an ordered type, since each conformance
35 -- type is stronger than the ones preceding it.
37 procedure Analyze_Abstract_Subprogram_Declaration
(N
: Node_Id
);
38 procedure Analyze_Expression_Function
(N
: Node_Id
);
39 procedure Analyze_Extended_Return_Statement
(N
: Node_Id
);
40 procedure Analyze_Function_Call
(N
: Node_Id
);
41 procedure Analyze_Operator_Symbol
(N
: Node_Id
);
42 procedure Analyze_Parameter_Association
(N
: Node_Id
);
43 procedure Analyze_Procedure_Call
(N
: Node_Id
);
44 procedure Analyze_Simple_Return_Statement
(N
: Node_Id
);
45 procedure Analyze_Subprogram_Declaration
(N
: Node_Id
);
46 procedure Analyze_Subprogram_Body
(N
: Node_Id
);
48 function Analyze_Subprogram_Specification
(N
: Node_Id
) return Entity_Id
;
49 -- Analyze subprogram specification in both subprogram declarations
50 -- and body declarations. Returns the defining entity for the
53 procedure Check_Conventions
(Typ
: Entity_Id
);
54 -- Ada 2005 (AI-430): Check that the conventions of all inherited and
55 -- overridden dispatching operations of type Typ are consistent with their
56 -- respective counterparts.
58 procedure Check_Delayed_Subprogram
(Designator
: Entity_Id
);
59 -- Designator can be a E_Subprogram_Type, E_Procedure or E_Function. If a
60 -- type in its profile depends on a private type without a full
61 -- declaration, indicate that the subprogram or type is delayed.
63 procedure Check_Discriminant_Conformance
67 -- Check that the discriminants of a full type N fully conform to the
68 -- discriminants of the corresponding partial view Prev. Prev_Loc indicates
69 -- the source location of the partial view, which may be different than
70 -- Prev in the case of private types.
72 procedure Check_Formal_Subprogram_Conformance
75 Err_Loc
: Node_Id
:= Empty
);
76 -- Check RM 6.3.1(17/3): the profile of a generic formal subprogram is not
77 -- subtype conformant with any other profile and post an error message if
78 -- either New_Id or Old_Id denotes a formal subprogram, with the flag being
79 -- placed on the Err_Loc node if it is specified, and on New_Id if not. See
80 -- also spec of Check_Fully_Conformant below for New_Id and Old_Id usage.
82 procedure Check_Fully_Conformant
85 Err_Loc
: Node_Id
:= Empty
);
86 -- Check that two callable entities (subprograms, entries, literals)
87 -- are fully conformant, post error message if not (RM 6.3.1(17)) with
88 -- the flag being placed on the Err_Loc node if it is specified, and
89 -- on the appropriate component of the New_Id construct if not. Note:
90 -- when checking spec/body conformance, New_Id must be the body entity
91 -- and Old_Id is the spec entity (the code in the implementation relies
92 -- on this ordering, and in any case, this makes sense, since if flags
93 -- are to be placed on the construct, they clearly belong on the body.
95 procedure Check_Mode_Conformant
98 Err_Loc
: Node_Id
:= Empty
;
99 Get_Inst
: Boolean := False);
100 -- Check that two callable entities (subprograms, entries, literals)
101 -- are mode conformant, post error message if not (RM 6.3.1(15)) with
102 -- the flag being placed on the Err_Loc node if it is specified, and
103 -- on the appropriate component of the New_Id construct if not. The
104 -- argument Get_Inst is set to True when this is a check against a
105 -- formal access-to-subprogram type, indicating that mapping of types
108 procedure Check_Overriding_Indicator
110 Overridden_Subp
: Entity_Id
;
111 Is_Primitive
: Boolean);
112 -- Verify the consistency of an overriding_indicator given for subprogram
113 -- declaration, body, renaming, or instantiation. Overridden_Subp is set
114 -- if the scope where we are introducing the subprogram contains a
115 -- type-conformant subprogram that becomes hidden by the new subprogram.
116 -- Is_Primitive indicates whether the subprogram is primitive.
118 procedure Check_Subtype_Conformant
121 Err_Loc
: Node_Id
:= Empty
;
122 Skip_Controlling_Formals
: Boolean := False;
123 Get_Inst
: Boolean := False);
124 -- Check that two callable entities (subprograms, entries, literals)
125 -- are subtype conformant, post error message if not (RM 6.3.1(16)),
126 -- the flag being placed on the Err_Loc node if it is specified, and
127 -- on the appropriate component of the New_Id construct if not.
128 -- Skip_Controlling_Formals is True when checking the conformance of
129 -- a subprogram that implements an interface operation. In that case,
130 -- only the non-controlling formals can (and must) be examined. The
131 -- argument Get_Inst is set to True when this is a check against a
132 -- formal access-to-subprogram type, indicating that mapping of types
135 procedure Check_Synchronized_Overriding
137 Overridden_Subp
: out Entity_Id
);
138 -- First determine if Def_Id is an entry or a subprogram either defined in
139 -- the scope of a task or protected type, or that is a primitive of such
140 -- a type. Check whether Def_Id overrides a subprogram of an interface
141 -- implemented by the synchronized type, returning the overridden entity
144 procedure Check_Type_Conformant
147 Err_Loc
: Node_Id
:= Empty
);
148 -- Check that two callable entities (subprograms, entries, literals)
149 -- are type conformant, post error message if not (RM 6.3.1(14)) with
150 -- the flag being placed on the Err_Loc node if it is specified, and
151 -- on the appropriate component of the New_Id construct if not.
153 function Conforming_Types
156 Ctype
: Conformance_Type
;
157 Get_Inst
: Boolean := False) return Boolean;
158 -- Check that the types of two formal parameters are conforming. In most
159 -- cases this is just a name comparison, but within an instance it involves
160 -- generic actual types, and in the presence of anonymous access types
161 -- it must examine the designated types. The argument Get_Inst is set to
162 -- True when this is a check against a formal access-to-subprogram type,
163 -- indicating that mapping of types is needed.
165 procedure Create_Extra_Formals
(E
: Entity_Id
);
166 -- For each parameter of a subprogram or entry that requires an additional
167 -- formal (such as for access parameters and indefinite discriminated
168 -- parameters), creates the appropriate formal and attach it to its
169 -- associated parameter. Each extra formal will also be appended to
170 -- the end of Subp's parameter list (with each subsequent extra formal
171 -- being attached to the preceding extra formal).
173 function Find_Corresponding_Spec
175 Post_Error
: Boolean := True) return Entity_Id
;
176 -- Use the subprogram specification in the body to retrieve the previous
177 -- subprogram declaration, if any.
179 function Fully_Conformant
(New_Id
, Old_Id
: Entity_Id
) return Boolean;
180 -- Determine whether two callable entities (subprograms, entries,
181 -- literals) are fully conformant (RM 6.3.1(17))
183 function Fully_Conformant_Expressions
186 Report
: Boolean := False) return Boolean;
187 -- Determines if two (non-empty) expressions are fully conformant
188 -- as defined by (RM 6.3.1(18-21))
190 function Fully_Conformant_Discrete_Subtypes
192 Given_S2
: Node_Id
) return Boolean;
193 -- Determines if two subtype definitions are fully conformant. Used
194 -- for entry family conformance checks (RM 6.3.1 (24)).
196 procedure Install_Entity
(E
: Entity_Id
);
197 -- Place a single entity on the visibility chain
199 procedure Install_Formals
(Id
: Entity_Id
);
200 -- On entry to a subprogram body, make the formals visible. Note that
201 -- simply placing the subprogram on the scope stack is not sufficient:
202 -- the formals must become the current entities for their names. This
203 -- procedure is also used to get visibility to the formals when analyzing
204 -- preconditions and postconditions appearing in the spec.
206 function Is_Interface_Conformant
207 (Tagged_Type
: Entity_Id
;
208 Iface_Prim
: Entity_Id
;
209 Prim
: Entity_Id
) return Boolean;
210 -- Returns true if both primitives have a matching name (including support
211 -- for names of inherited private primitives --which have suffix 'P'), they
212 -- are type conformant, and Prim is defined in the scope of Tagged_Type.
213 -- Special management is done for functions returning interfaces.
215 procedure List_Inherited_Pre_Post_Aspects
(E
: Entity_Id
);
216 -- E is the entity for a subprogram or generic subprogram spec. This call
217 -- lists all inherited Pre/Post aspects if List_Inherited_Pre_Post is True.
219 procedure May_Need_Actuals
(Fun
: Entity_Id
);
220 -- Flag functions that can be called without parameters, i.e. those that
221 -- have no parameters, or those for which defaults exist for all parameters
222 -- Used for subprogram declarations and for access subprogram declarations,
223 -- where they apply to the anonymous designated type. On return the flag
224 -- Set_Needs_No_Actuals is set appropriately in Fun.
226 function Mode_Conformant
(New_Id
, Old_Id
: Entity_Id
) return Boolean;
227 -- Determine whether two callable entities (subprograms, entries,
228 -- literals) are mode conformant (RM 6.3.1(15))
230 procedure New_Overloaded_Entity
232 Derived_Type
: Entity_Id
:= Empty
);
233 -- Process new overloaded entity. Overloaded entities are created by
234 -- enumeration type declarations, subprogram specifications, entry
235 -- declarations, and (implicitly) by type derivations. If Derived_Type
236 -- is non-empty then this is a subprogram derived for that type.
238 procedure Process_Formals
(T
: List_Id
; Related_Nod
: Node_Id
);
239 -- Enter the formals in the scope of the subprogram or entry, and
240 -- analyze default expressions if any. The implicit types created for
241 -- access parameter are attached to the Related_Nod which comes from the
244 procedure Reference_Body_Formals
(Spec
: Entity_Id
; Bod
: Entity_Id
);
245 -- If there is a separate spec for a subprogram or generic subprogram, the
246 -- formals of the body are treated as references to the corresponding
247 -- formals of the spec. This reference does not count as an actual use of
248 -- the formal, in order to diagnose formals that are unused in the body.
249 -- This procedure is also used in renaming_as_body declarations, where
250 -- the formals of the specification must be treated as body formals that
251 -- correspond to the previous subprogram declaration, and not as new
252 -- entities with their defining entry in the cross-reference information.
254 procedure Set_Actual_Subtypes
(N
: Node_Id
; Subp
: Entity_Id
);
255 -- If the formals of a subprogram are unconstrained, build a subtype
256 -- declaration that uses the bounds or discriminants of the actual to
257 -- construct an actual subtype for them. This is an optimization that
258 -- is done only in some cases where the actual subtype cannot change
259 -- during execution of the subprogram. By setting the actual subtype
260 -- once, we avoid recomputing it unnecessarily.
262 procedure Set_Formal_Mode
(Formal_Id
: Entity_Id
);
263 -- Set proper Ekind to reflect formal mode (in, out, in out)
265 function Subtype_Conformant
268 Skip_Controlling_Formals
: Boolean := False) return Boolean;
269 -- Determine whether two callable entities (subprograms, entries, literals)
270 -- are subtype conformant (RM 6.3.1(16)). Skip_Controlling_Formals is True
271 -- when checking the conformance of a subprogram that implements an
272 -- interface operation. In that case, only the non-controlling formals
273 -- can (and must) be examined.
275 function Type_Conformant
278 Skip_Controlling_Formals
: Boolean := False) return Boolean;
279 -- Determine whether two callable entities (subprograms, entries, literals)
280 -- are type conformant (RM 6.3.1(14)). Skip_Controlling_Formals is True
281 -- when checking the conformance of a subprogram that implements an
282 -- interface operation. In that case, only the non-controlling formals
283 -- can (and must) be examined.
285 procedure Valid_Operator_Definition
(Designator
: Entity_Id
);
286 -- Verify that an operator definition has the proper number of formals