1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2022, 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 -- Package containing utility procedures used throughout the semantics
28 with Aspects
; use Aspects
;
29 with Atree
; use Atree
;
30 with Einfo
; use Einfo
;
31 with Einfo
.Entities
; use Einfo
.Entities
;
32 with Exp_Tss
; use Exp_Tss
;
33 with Namet
; use Namet
;
35 with Snames
; use Snames
;
36 with Types
; use Types
;
37 with Uintp
; use Uintp
;
38 with Urealp
; use Urealp
;
42 function Abstract_Interface_List
(Typ
: Entity_Id
) return List_Id
;
43 -- The list of interfaces implemented by Typ. Empty if there are none,
44 -- including the cases where there can't be any because e.g. the type is
47 type Accessibility_Level_Kind
is
50 Zero_On_Dynamic_Level
);
51 -- Accessibility_Level_Kind is an enumerated type which captures the
52 -- different modes in which an accessibility level could be obtained for
53 -- a given expression.
55 -- When in the context of the function Accessibility_Level,
56 -- Accessibility_Level_Kind signals what type of accessibility level to
57 -- obtain. For example, when Level is Dynamic_Level, a defining identifier
58 -- associated with a SAOOAAT may be returned or an N_Integer_Literal node.
59 -- When the level is Object_Decl_Level, an N_Integer_Literal node is
60 -- returned containing the level of the declaration of the object if
61 -- relevant (be it a SAOOAAT or otherwise). Finally, Zero_On_Dynamic_Level
62 -- returns library level for all cases where the accessibility level is
63 -- dynamic (used to bypass static accessibility checks in dynamic cases).
65 function Accessibility_Level
67 Level
: Accessibility_Level_Kind
;
68 In_Return_Context
: Boolean := False;
69 Allow_Alt_Model
: Boolean := True) return Node_Id
;
70 -- Centralized accessibility level calculation routine for finding the
71 -- accessibility level of a given expression Expr.
73 -- In_Return_Context forces the Accessibility_Level calculations to be
74 -- carried out "as if" Expr existed in a return value. This is useful for
75 -- calculating the accessibility levels for discriminant associations
76 -- and return aggregates.
78 -- The Allow_Alt_Model parameter allows the alternative level calculation
79 -- under the restriction No_Dynamic_Accessibility_Checks to be performed.
81 function Acquire_Warning_Match_String
(Str_Lit
: Node_Id
) return String;
82 -- Used by pragma Warnings (Off, string), and Warn_As_Error (string) to get
83 -- the given string argument, adding leading and trailing asterisks if they
84 -- are not already present. Str_Lit is the static value of the pragma
87 procedure Add_Access_Type_To_Process
(E
: Entity_Id
; A
: Entity_Id
);
88 -- Add A to the list of access types to process when expanding the
91 procedure Add_Block_Identifier
(N
: Node_Id
; Id
: out Entity_Id
);
92 -- Given a block statement N, generate an internal E_Block label and make
93 -- it the identifier of the block. Id denotes the generated entity. If the
94 -- block already has an identifier, Id returns the entity of its label.
96 procedure Add_Global_Declaration
(N
: Node_Id
);
97 -- These procedures adds a declaration N at the library level, to be
98 -- elaborated before any other code in the unit. It is used for example
99 -- for the entity that marks whether a unit has been elaborated. The
100 -- declaration is added to the Declarations list of the Aux_Decls_Node
101 -- for the current unit. The declarations are added in the current scope,
102 -- so the caller should push a new scope as required before the call.
104 function Add_Suffix
(E
: Entity_Id
; Suffix
: Character) return Name_Id
;
105 -- Returns the name of E adding Suffix
107 function Address_Integer_Convert_OK
(T1
, T2
: Entity_Id
) return Boolean;
108 -- Given two types, returns True if we are in Allow_Integer_Address mode
109 -- and one of the types is (a descendant of) System.Address (and this type
110 -- is private), and the other type is any integer type.
112 function Address_Value
(N
: Node_Id
) return Node_Id
;
113 -- Return the underlying value of the expression N of an address clause
115 function Addressable
(V
: Uint
) return Boolean;
116 function Addressable
(V
: Int
) return Boolean;
117 pragma Inline
(Addressable
);
118 -- Returns True if the value of V is the word size or an addressable factor
119 -- or multiple of the word size (typically 8, 16, 32, 64 or 128).
121 procedure Aggregate_Constraint_Checks
123 Check_Typ
: Entity_Id
);
124 -- Checks expression Exp against subtype Check_Typ. If Exp is an aggregate
125 -- and Check_Typ a constrained record type with discriminants, we generate
126 -- the appropriate discriminant checks. If Exp is an array aggregate then
127 -- emit the appropriate length checks. If Exp is a scalar type, or a string
128 -- literal, Exp is changed into Check_Typ'(Exp) to ensure that range checks
129 -- are performed at run time. Also used for expressions in the argument of
130 -- 'Update, which shares some of the features of an aggregate.
132 function Alignment_In_Bits
(E
: Entity_Id
) return Uint
;
133 -- If the alignment of the type or object E is currently known to the
134 -- compiler, then this function returns the alignment value in bits.
135 -- Otherwise Uint_0 is returned, indicating that the alignment of the
136 -- entity is not yet known to the compiler.
138 function All_Composite_Constraints_Static
(Constr
: Node_Id
) return Boolean;
139 -- Used to implement pragma Restrictions (No_Dynamic_Sized_Objects).
140 -- Given a constraint or subtree of a constraint on a composite
141 -- subtype/object, returns True if there are no nonstatic constraints,
142 -- which might cause objects to be created with dynamic size.
143 -- Called for subtype declarations (including implicit ones created for
144 -- subtype indications in object declarations, as well as discriminated
145 -- record aggregate cases). For record aggregates, only records containing
146 -- discriminant-dependent arrays matter, because the discriminants must be
147 -- static when governing a variant part. Access discriminants are
148 -- irrelevant. Also called for array aggregates, but only named notation,
149 -- because those are the only dynamic cases.
151 procedure Append_Entity_Name
(Buf
: in out Bounded_String
; E
: Entity_Id
);
152 -- Recursive procedure to construct string for qualified name of enclosing
153 -- program unit. The qualification stops at an enclosing scope has no
154 -- source name (block or loop). If entity is a subprogram instance, skip
155 -- enclosing wrapper package. The name is appended to Buf.
157 procedure Append_Inherited_Subprogram
(S
: Entity_Id
);
158 -- If the parent of the operation is declared in the visible part of
159 -- the current scope, the inherited operation is visible even though the
160 -- derived type that inherits the operation may be completed in the private
161 -- part of the current package.
163 procedure Apply_Compile_Time_Constraint_Error
166 Reason
: RT_Exception_Code
;
167 Ent
: Entity_Id
:= Empty
;
168 Typ
: Entity_Id
:= Empty
;
169 Loc
: Source_Ptr
:= No_Location
;
170 Warn
: Boolean := False;
171 Emit_Message
: Boolean := True);
172 -- N is a subexpression that will raise Constraint_Error when evaluated
173 -- at run time. Msg is a message that explains the reason for raising the
174 -- exception. The last character is ? if the message is always a warning,
175 -- even in Ada 95, and is not a ? if the message represents an illegality
176 -- (because of violation of static expression rules) in Ada 95 (but not
177 -- in Ada 83). Typically this routine posts all messages at the Sloc of
178 -- node N. However, if Loc /= No_Location, Loc is the Sloc used to output
179 -- the message. After posting the appropriate message, this routine
180 -- replaces the expression with an appropriate N_Raise_Constraint_Error
181 -- node using the given Reason code. This node is then marked as being
182 -- static if the original node is static, but sets the flag
183 -- Raises_Constraint_Error, preventing further evaluation. The error
184 -- message may contain a } or & insertion character. This normally
185 -- references Etype (N), unless the Ent argument is given explicitly, in
186 -- which case it is used instead. The type of the raise node that is built
187 -- is normally Etype (N), but if the Typ parameter is present, this is used
188 -- instead. Warn is normally False. If it is True then the message is
189 -- treated as a warning even though it does not end with a ? (this is used
190 -- when the caller wants to parameterize whether an error or warning is
191 -- given), or when the message should be treated as a warning even when
192 -- SPARK_Mode is On (which otherwise would force an error).
193 -- If Emit_Message is False, then do not emit any message.
195 function Async_Readers_Enabled
(Id
: Entity_Id
) return Boolean;
196 -- Id should be the entity of a state abstraction, an object, or a type.
197 -- Returns True iff Id is subject to external property Async_Readers.
199 function Async_Writers_Enabled
(Id
: Entity_Id
) return Boolean;
200 -- Id should be the entity of a state abstraction, an object, or a type.
201 -- Returns True iff Id is subject to external property Async_Writers.
203 function Available_Full_View_Of_Component
(T
: Entity_Id
) return Boolean;
204 -- If at the point of declaration an array type has a private or limited
205 -- component, several array operations are not available on the type, and
206 -- the array type is flagged accordingly. If in the immediate scope of
207 -- the array type the component becomes non-private or non-limited, these
208 -- operations become available. This can happen if the scopes of both types
209 -- are open, and the scope of the array is not outside the scope of the
215 Warn
: Boolean := False);
216 -- Called when node N is expected to contain a valid aspect name, and
217 -- Nam is found instead. If Warn is set True this is a warning, else this
220 procedure Bad_Attribute
223 Warn
: Boolean := False);
224 -- Called when node N is expected to contain a valid attribute name, and
225 -- Nam is found instead. If Warn is set True this is a warning, else this
228 procedure Bad_Predicated_Subtype_Use
232 Suggest_Static
: Boolean := False);
233 -- This is called when Typ, a predicated subtype, is used in a context
234 -- which does not allow the use of a predicated subtype. Msg is passed to
235 -- Error_Msg_FE to output an appropriate message using N as the location,
236 -- and Typ as the entity. The caller must set up any insertions other than
237 -- the & for the type itself. Note that if Typ is a generic actual type,
238 -- then the message will be output as a warning, and a raise Program_Error
239 -- is inserted using Insert_Action with node N as the insertion point. Node
240 -- N also supplies the source location for construction of the raise node.
241 -- If Typ does not have any predicates, the call has no effect. Set flag
242 -- Suggest_Static when the context warrants an advice on how to avoid the
245 function Bad_Unordered_Enumeration_Reference
247 T
: Entity_Id
) return Boolean;
248 -- Node N contains a potentially dubious reference to type T, either an
249 -- explicit comparison, or an explicit range. This function returns True
250 -- if the type T is an enumeration type for which No pragma Order has been
251 -- given, and the reference N is not in the same extended source unit as
252 -- the declaration of T.
254 function Begin_Keyword_Location
(N
: Node_Id
) return Source_Ptr
;
255 -- Given block statement, entry body, package body, subprogram body, or
256 -- task body N, return the closest source location to the "begin" keyword.
258 function Build_Actual_Subtype
260 N
: Node_Or_Entity_Id
) return Node_Id
;
261 -- Build an anonymous subtype for an entity or expression, using the
262 -- bounds of the entity or the discriminants of the enclosing record.
263 -- T is the type for which the actual subtype is required, and N is either
264 -- a defining identifier, or any subexpression.
266 function Build_Actual_Subtype_Of_Component
268 N
: Node_Id
) return Node_Id
;
269 -- Determine whether a selected component has a type that depends on
270 -- discriminants, and build actual subtype for it if so.
272 -- Handling of inherited primitives whose ancestors have class-wide
273 -- pre/postconditions.
275 -- If a primitive operation of a parent type has a class-wide pre/post-
276 -- condition that includes calls to other primitives, and that operation
277 -- is inherited by a descendant type that also overrides some of these
278 -- other primitives, the condition that applies to the inherited
279 -- operation has a modified condition in which the overridden primitives
280 -- have been replaced by the primitives of the descendent type. A call
281 -- to the inherited operation cannot be simply a call to the parent
282 -- operation (with an appropriate conversion) as is the case for other
283 -- inherited operations, but must appear with a wrapper subprogram to which
284 -- the modified conditions apply. Furthermore the call to the parent
285 -- operation must not be subject to the original class-wide condition,
286 -- given that modified conditions apply. To implement these semantics
287 -- economically we create a subprogram body (a "class-wide clone") to
288 -- which no pre/postconditions apply, and we create bodies for the
289 -- original and the inherited operation that have their respective
290 -- pre/postconditions and simply call the clone. The following operations
291 -- take care of constructing declaration and body of the clone, and
292 -- building the calls to it within the appropriate wrappers.
294 procedure Build_Constrained_Itype
297 New_Assoc_List
: List_Id
);
298 -- Build a constrained itype for the newly created record aggregate N and
299 -- set it as a type of N. The itype will have Typ as its base type and
300 -- will be constrained by the values of discriminants from the component
301 -- association list New_Assoc_List.
303 -- ??? This code used to be pretty much a copy of Build_Subtype, but now
304 -- those two routines behave differently for types with unknown
305 -- discriminants. They are both exported in from this package in the hope
306 -- to eventually unify them (a not duplicate them even more until then).
308 -- ??? Performance WARNING. The current implementation creates a new itype
309 -- for all aggregates whose base type is discriminated. This means that
310 -- for record aggregates nested inside an array aggregate we will create
311 -- a new itype for each record aggregate if the array component type has
312 -- discriminants. For large aggregates this may be a problem. What should
313 -- be done in this case is to reuse itypes as much as possible.
315 function Build_Default_Subtype
317 N
: Node_Id
) return Entity_Id
;
318 -- If T is an unconstrained type with defaulted discriminants, build a
319 -- subtype constrained by the default values, insert the subtype
320 -- declaration in the tree before N, and return the entity of that
321 -- subtype. Otherwise, simply return T.
323 function Build_Default_Subtype_OK
(T
: Entity_Id
) return Boolean;
324 -- When analyzing components or object declarations, it is possible, in
325 -- some cases, to build subtypes for discriminated types. This is
326 -- worthwhile to avoid the backend allocating the maximum possible size for
327 -- objects of the type.
328 -- In particular, when T is limited, the discriminants and therefore the
329 -- size of an object of type T cannot change. Furthermore, if T is definite
330 -- with statically initialized defaulted discriminants, we are able and
331 -- want to build a constrained subtype of the right size.
333 function Build_Discriminal_Subtype_Of_Component
334 (T
: Entity_Id
) return Node_Id
;
335 -- Determine whether a record component has a type that depends on
336 -- discriminants, and build actual subtype for it if so.
338 procedure Build_Elaboration_Entity
(N
: Node_Id
; Spec_Id
: Entity_Id
);
339 -- Given a compilation unit node N, allocate an elaboration counter for
340 -- the compilation unit, and install it in the Elaboration_Entity field
341 -- of Spec_Id, the entity for the compilation unit.
343 procedure Build_Explicit_Dereference
346 -- AI05-139: Names with implicit dereference. If the expression N is a
347 -- reference type and the context imposes the corresponding designated
348 -- type, convert N into N.Disc.all. Such expressions are always over-
349 -- loaded with both interpretations, and the dereference interpretation
350 -- carries the name of the reference discriminant.
352 function Build_Overriding_Spec
354 Typ
: Entity_Id
) return Node_Id
;
355 -- Build a subprogram specification for the wrapper of an inherited
356 -- operation with a modified pre- or postcondition (See AI12-0113).
357 -- Op is the parent operation, and Typ is the descendant type that
358 -- inherits the operation.
360 function Build_Subtype
361 (Related_Node
: Node_Id
;
364 Constraints
: List_Id
)
366 -- Typ is an array or discriminated type, Constraints is a list of
367 -- constraints that apply to Typ. This routine builds the constrained
368 -- subtype using Loc as the source location and attached this subtype
369 -- declaration to Related_Node. The returned subtype inherits predicates
372 -- ??? The routine is mostly a duplicate of Build_Constrained_Itype, so be
373 -- careful which of the two better suits your needs (and certainly do not
374 -- duplicate their code).
376 function Cannot_Raise_Constraint_Error
(Expr
: Node_Id
) return Boolean;
377 -- Returns True if the expression cannot possibly raise Constraint_Error.
378 -- The response is conservative in the sense that a result of False does
379 -- not necessarily mean that CE could be raised, but a response of True
380 -- means that for sure CE cannot be raised.
382 procedure Check_Ambiguous_Aggregate
(Call
: Node_Id
);
383 -- Additional information on an ambiguous call in Ada_2022 when a
384 -- subprogram call has an actual that is an aggregate, and the
385 -- presence of container aggregates (or types with the corresponding
386 -- aspect) provides an additional interpretation. Message indicates
387 -- that an aggregate actual should carry a type qualification.
389 procedure Check_Dynamically_Tagged_Expression
392 Related_Nod
: Node_Id
);
393 -- Check wrong use of dynamically tagged expression
395 procedure Check_Fully_Declared
(T
: Entity_Id
; N
: Node_Id
);
396 -- Verify that the full declaration of type T has been seen. If not, place
397 -- error message on node N. Used in object declarations, type conversions
398 -- and qualified expressions.
400 procedure Check_Function_With_Address_Parameter
(Subp_Id
: Entity_Id
);
401 -- A subprogram that has an Address parameter and is declared in a Pure
402 -- package is not considered Pure, because the parameter may be used as a
403 -- pointer and the referenced data may change even if the address value
405 -- If the programmer gave an explicit Pure_Function pragma, then we respect
406 -- the pragma and leave the subprogram Pure.
408 procedure Check_Function_Writable_Actuals
(N
: Node_Id
);
409 -- (Ada 2012): If the construct N has two or more direct constituents that
410 -- are names or expressions whose evaluation may occur in an arbitrary
411 -- order, at least one of which contains a function call with an in out or
412 -- out parameter, then the construct is legal only if: for each name that
413 -- is passed as a parameter of mode in out or out to some inner function
414 -- call C2 (not including the construct N itself), there is no other name
415 -- anywhere within a direct constituent of the construct C other than
416 -- the one containing C2, that is known to refer to the same object (RM
419 procedure Check_Implicit_Dereference
(N
: Node_Id
; Typ
: Entity_Id
);
420 -- AI05-139-2: Accessors and iterators for containers. This procedure
421 -- checks whether T is a reference type, and if so it adds an interprettion
422 -- to N whose type is the designated type of the reference_discriminant.
423 -- If N is a generalized indexing operation, the interpretation is added
424 -- both to the corresponding function call, and to the indexing node.
426 procedure Check_Internal_Protected_Use
(N
: Node_Id
; Nam
: Entity_Id
);
427 -- Within a protected function, the current object is a constant, and
428 -- internal calls to a procedure or entry are illegal. Similarly, other
429 -- uses of a protected procedure in a renaming or a generic instantiation
430 -- in the context of a protected function are illegal (AI05-0225).
432 procedure Check_Later_Vs_Basic_Declarations
434 During_Parsing
: Boolean);
435 -- If During_Parsing is True, check for misplacement of later vs basic
436 -- declarations in Ada 83. If During_Parsing is False, and the SPARK
437 -- restriction is set, do the same: although SPARK 95 removes the
438 -- distinction between initial and later declarative items, the distinction
439 -- remains in the Examiner (JB01-005). Note that the Examiner does not
440 -- count package declarations in later declarative items.
442 procedure Check_No_Hidden_State
(Id
: Entity_Id
);
443 -- Determine whether object or state Id introduces a hidden state. If this
444 -- is the case, emit an error.
446 procedure Check_Inherited_Nonoverridable_Aspects
447 (Inheritor
: Entity_Id
;
448 Interface_List
: List_Id
;
449 Parent_Type
: Entity_Id
);
450 -- Verify consistency of inherited nonoverridable aspects
451 -- when aspects are inherited from more than one source.
452 -- Parent_Type may be void (e.g., for a tagged task/protected type
453 -- whose declaration includes a non-empty interface list).
454 -- In the error case, error message is associate with Inheritor;
455 -- Inheritor parameter is otherwise unused.
457 procedure Check_Nonvolatile_Function_Profile
(Func_Id
: Entity_Id
);
458 -- Verify that the profile of nonvolatile function Func_Id does not contain
459 -- effectively volatile parameters or return type for reading.
461 function Check_Parents
(N
: Node_Id
; List
: Elist_Id
) return Boolean;
462 -- Return True if all the occurrences of subtree N referencing entities in
463 -- the given List have the right value in their Parent field.
465 procedure Check_Part_Of_Reference
(Var_Id
: Entity_Id
; Ref
: Node_Id
);
466 -- Verify the legality of reference Ref to variable Var_Id when the
467 -- variable is a constituent of a single protected/task type.
469 procedure Check_Potentially_Blocking_Operation
(N
: Node_Id
);
470 -- N is one of the statement forms that is a potentially blocking
471 -- operation. If it appears within a protected action, emit warning.
473 procedure Check_Previous_Null_Procedure
476 -- A null procedure or a subprogram renaming can complete a previous
477 -- declaration, unless that previous declaration is itself a null
478 -- procedure. This must be treated specially because the analysis of
479 -- the null procedure leaves the corresponding entity as having no
480 -- completion, because its completion is provided by a generated body
481 -- inserted after all other declarations.
483 procedure Check_Result_And_Post_State
(Subp_Id
: Entity_Id
);
484 -- Determine whether the contract of subprogram Subp_Id mentions attribute
485 -- 'Result and it contains an expression that evaluates differently in pre-
488 procedure Check_State_Refinements
490 Is_Main_Unit
: Boolean := False);
491 -- Verify that all abstract states declared in a block statement, entry
492 -- body, package body, protected body, subprogram body, task body, or a
493 -- package declaration denoted by Context have proper refinement. Emit an
494 -- error if this is not the case. Flag Is_Main_Unit should be set when
495 -- Context denotes the main compilation unit.
497 procedure Check_Unused_Body_States
(Body_Id
: Entity_Id
);
498 -- Verify that all abstract states and objects declared in the state space
499 -- of package body Body_Id are used as constituents. Emit an error if this
502 procedure Check_Unprotected_Access
505 -- Check whether the expression is a pointer to a protected component,
506 -- and the context is external to the protected operation, to warn against
507 -- a possible unlocked access to data.
509 procedure Check_Volatility_Compatibility
510 (Id1
, Id2
: Entity_Id
;
511 Description_1
, Description_2
: String;
512 Srcpos_Bearer
: Node_Id
);
513 -- Id1 and Id2 should each be the entity of a state abstraction, a
514 -- variable, or a type (i.e., something suitable for passing to
515 -- Async_Readers_Enabled and similar functions).
516 -- Does nothing if SPARK_Mode /= On. Otherwise, flags a legality violation
517 -- if one or more of the four volatility-related aspects is False for Id1
518 -- and True for Id2. The two descriptions are included in the error message
519 -- text; the source position for the generated message is determined by
522 function Choice_List
(N
: Node_Id
) return List_Id
;
523 -- Utility to retrieve the choices of a Component_Association or the
524 -- Discrete_Choices of an Iterated_Component_Association. For various
525 -- reasons these nodes have a different structure even though they play
526 -- similar roles in array aggregates.
528 type Condition_Kind
is
529 (Ignored_Class_Precondition
,
530 Ignored_Class_Postcondition
,
532 Class_Postcondition
);
533 -- Kind of class-wide conditions
535 function Class_Condition
536 (Kind
: Condition_Kind
;
537 Subp
: Entity_Id
) return Node_Id
;
538 -- Class-wide Kind condition of Subp
540 function Collect_Body_States
(Body_Id
: Entity_Id
) return Elist_Id
;
541 -- Gather the entities of all abstract states and objects declared in the
542 -- body state space of package body Body_Id.
544 procedure Collect_Interfaces
546 Ifaces_List
: out Elist_Id
;
547 Exclude_Parents
: Boolean := False;
548 Use_Full_View
: Boolean := True);
549 -- Ada 2005 (AI-251): Collect whole list of abstract interfaces that are
550 -- directly or indirectly implemented by T. Exclude_Parents is used to
551 -- avoid the addition of inherited interfaces to the generated list.
552 -- Use_Full_View is used to collect the interfaces using the full-view
555 procedure Collect_Interface_Components
556 (Tagged_Type
: Entity_Id
;
557 Components_List
: out Elist_Id
);
558 -- Ada 2005 (AI-251): Collect all the tag components associated with the
559 -- secondary dispatch tables of a tagged type.
561 procedure Collect_Interfaces_Info
563 Ifaces_List
: out Elist_Id
;
564 Components_List
: out Elist_Id
;
565 Tags_List
: out Elist_Id
);
566 -- Ada 2005 (AI-251): Collect all the interfaces associated with T plus
567 -- the record component and tag associated with each of these interfaces.
568 -- On exit Ifaces_List, Components_List and Tags_List have the same number
569 -- of elements, and elements at the same position on these tables provide
570 -- information on the same interface type.
572 procedure Collect_Parents
575 Use_Full_View
: Boolean := True);
576 -- Collect all the parents of Typ. Use_Full_View is used to collect them
577 -- using the full-view of private parents (if available).
579 function Collect_Primitive_Operations
(T
: Entity_Id
) return Elist_Id
;
580 -- Called upon type derivation and extension. We scan the declarative part
581 -- in which the type appears, and collect subprograms that have one
582 -- subsidiary subtype of the type. These subprograms can only appear after
585 function Compile_Time_Constraint_Error
588 Ent
: Entity_Id
:= Empty
;
589 Loc
: Source_Ptr
:= No_Location
;
590 Warn
: Boolean := False;
591 Extra_Msg
: String := "") return Node_Id
;
592 -- This is similar to Apply_Compile_Time_Constraint_Error in that it
593 -- generates a warning (or error) message in the same manner, but it does
594 -- not replace any nodes. For convenience, the function always returns its
595 -- first argument. The message is a warning if the message ends with ?, or
596 -- we are operating in Ada 83 mode, or the Warn parameter is set to True.
597 -- If Extra_Msg is not a null string, then it's associated with N and
598 -- emitted immediately after the main message (and before output of any
599 -- message indicating that Constraint_Error will be raised).
601 procedure Compute_Returns_By_Ref
(Func
: Entity_Id
);
602 -- Set the Returns_By_Ref flag on Func if appropriate
605 with function Predicate
(Typ
: Entity_Id
) return Boolean;
606 function Collect_Types_In_Hierarchy
608 Examine_Components
: Boolean := False) return Elist_Id
;
609 -- Inspect the ancestor and progenitor types of Typ and Typ itself -
610 -- collecting those for which function Predicate is True. The resulting
611 -- list is ordered in a type-to-ultimate-ancestor fashion.
613 -- When Examine_Components is True, components types in the hierarchy also
616 procedure Conditional_Delay
(New_Ent
, Old_Ent
: Entity_Id
);
617 -- Sets the Has_Delayed_Freeze flag of New_Ent if the Delayed_Freeze flag
618 -- of Old_Ent is set and Old_Ent has not yet been Frozen (i.e. Is_Frozen is
621 function Copy_Component_List
623 Loc
: Source_Ptr
) return List_Id
;
624 -- Copy components from record type R_Typ that come from source. Used to
625 -- create a new compatible record type. Loc is the source location assigned
626 -- to the created nodes.
628 function Copy_Parameter_List
(Subp_Id
: Entity_Id
) return List_Id
;
629 -- Utility to create a parameter profile for a new subprogram spec, when
630 -- the subprogram has a body that acts as spec. This is done for some cases
631 -- of inlining, and for private protected ops. Also used to create bodies
632 -- for stubbed subprograms.
634 procedure Copy_SPARK_Mode_Aspect
(From
: Node_Id
; To
: Node_Id
);
635 -- Copy the SPARK_Mode aspect if present in the aspect specifications
636 -- of node From to node To. On entry it is assumed that To does not have
637 -- aspect specifications. If From has no aspects, the routine has no
640 function Copy_Subprogram_Spec
642 New_Sloc
: Source_Ptr
:= No_Location
) return Node_Id
;
643 -- Replicate a function or a procedure specification denoted by Spec. The
644 -- resulting tree is an exact duplicate of the original tree. New entities
645 -- are created for the unit name and the formal parameters. For definition
646 -- of New_Sloc, see the comment for New_Copy_Tree.
648 function Corresponding_Generic_Type
(T
: Entity_Id
) return Entity_Id
;
649 -- If a type is a generic actual type, return the corresponding formal in
650 -- the generic parent unit. There is no direct link in the tree for this
651 -- attribute, except in the case of formal private and derived types.
652 -- Possible optimization???
654 function Corresponding_Primitive_Op
655 (Ancestor_Op
: Entity_Id
;
656 Descendant_Type
: Entity_Id
) return Entity_Id
;
657 -- Given a primitive subprogram of a tagged type and a (distinct)
658 -- descendant type of that type, find the corresponding primitive
659 -- subprogram of the descendant type.
661 function Current_Entity
(N
: Node_Id
) return Entity_Id
;
662 pragma Inline
(Current_Entity
);
663 -- Find the currently visible definition for a given identifier, that is to
664 -- say the first entry in the visibility chain for the Chars of N.
666 function Current_Entity_In_Scope
(N
: Name_Id
) return Entity_Id
;
667 function Current_Entity_In_Scope
(N
: Node_Id
) return Entity_Id
;
668 -- Find whether there is a previous definition for name or identifier N in
669 -- the current scope. Because declarations for a scope are not necessarily
670 -- contiguous (e.g. for packages) the first entry on the visibility chain
671 -- for N is not necessarily in the current scope.
673 function Current_Scope
return Entity_Id
;
674 -- Get entity representing current scope
676 function Current_Scope_No_Loops
return Entity_Id
;
677 -- Return the current scope ignoring internally generated loops
679 function Current_Subprogram
return Entity_Id
;
680 -- Returns current enclosing subprogram. If Current_Scope is a subprogram,
681 -- then that is what is returned, otherwise the Enclosing_Subprogram of the
682 -- Current_Scope is returned. The returned value is Empty if this is called
683 -- from a library package which is not within any subprogram.
685 function CW_Or_Needs_Finalization
(Typ
: Entity_Id
) return Boolean;
686 -- True if Typ is a class-wide type or requires finalization actions. Same
687 -- as Needs_Finalization except with pragma Restrictions (No_Finalization),
688 -- in which case we know that class-wide objects do not need finalization.
690 function Deepest_Type_Access_Level
692 Allow_Alt_Model
: Boolean := True) return Uint
;
694 -- Same as Type_Access_Level, except that if the type is the type of an Ada
695 -- 2012 stand-alone object of an anonymous access type, then return the
696 -- static accessibility level of the object. In that case, the dynamic
697 -- accessibility level of the object may take on values in a range. The low
698 -- bound of that range is returned by Type_Access_Level; this function
699 -- yields the high bound of that range. Also differs from Type_Access_Level
700 -- in the case of a descendant of a generic formal type (returns Int'Last
703 -- The Allow_Alt_Model parameter allows the alternative level calculation
704 -- under the restriction No_Dynamic_Accessibility_Checks to be performed.
706 function Defining_Entity
(N
: Node_Id
) return Entity_Id
;
707 -- Given a declaration N, returns the associated defining entity. If the
708 -- declaration has a specification, the entity is obtained from the
709 -- specification. If the declaration has a defining unit name, then the
710 -- defining entity is obtained from the defining unit name ignoring any
711 -- child unit prefixes.
713 -- Iterator loops also have a defining entity, which holds the list of
714 -- local entities declared during loop expansion. These entities need
715 -- debugging information, generated through Qualify_Entity_Names, and
716 -- the loop declaration must be placed in the table Name_Qualify_Units.
718 -- WARNING: There is a matching C declaration of this subprogram in fe.h
720 function Defining_Entity_Or_Empty
(N
: Node_Id
) return Entity_Id
;
721 -- This is equivalent to Defining_Entity but it returns Empty for nodes
722 -- without an entity instead of raising Program_Error.
724 function Denotes_Discriminant
726 Check_Concurrent
: Boolean := False) return Boolean;
727 -- Returns True if node N is an Entity_Name node for a discriminant. If the
728 -- flag Check_Concurrent is true, function also returns true when N denotes
729 -- the discriminal of the discriminant of a concurrent type. This is needed
730 -- to disable some optimizations on private components of protected types,
731 -- and constraint checks on entry families constrained by discriminants.
733 function Denotes_Same_Object
(A1
, A2
: Node_Id
) return Boolean;
734 -- Detect suspicious overlapping between actuals in a call, when both are
735 -- writable (RM 2012 6.4.1(6.4/3)).
737 function Denotes_Same_Prefix
(A1
, A2
: Node_Id
) return Boolean;
738 -- Functions to detect suspicious overlapping between actuals in a call,
739 -- when one of them is writable. The predicates are those proposed in
740 -- AI05-0144, to detect dangerous order dependence in complex calls.
741 -- I would add a parameter Warn which enables more extensive testing of
742 -- cases as we find appropriate when we are only warning ??? Or perhaps
743 -- return an indication of (Error, Warn, OK) ???
745 function Denotes_Variable
(N
: Node_Id
) return Boolean;
746 -- Returns True if node N denotes a single variable without parentheses
748 function Depends_On_Discriminant
(N
: Node_Id
) return Boolean;
749 -- Returns True if N denotes a discriminant or if N is a range, a subtype
750 -- indication or a scalar subtype where one of the bounds is a
753 function Derivation_Too_Early_To_Inherit
754 (Typ
: Entity_Id
; Streaming_Op
: TSS_Name_Type
) return Boolean;
755 -- Returns True if Typ is a derived type, the given Streaming_Op
756 -- (one of Read, Write, Input, or Output) is explicitly specified
757 -- for Typ's parent type, and that attribute specification is *not*
758 -- inherited by Typ because the declaration of Typ precedes that
759 -- of the attribute specification.
761 function Designate_Same_Unit
763 Name2
: Node_Id
) return Boolean;
764 -- Returns True if Name1 and Name2 designate the same unit name; each of
765 -- these names is supposed to be a selected component name, an expanded
766 -- name, a defining program unit name or an identifier.
768 procedure Diagnose_Iterated_Component_Association
(N
: Node_Id
);
769 -- Emit an error if iterated component association N is actually an illegal
770 -- quantified expression lacking a quantifier.
772 function Discriminated_Size
(Comp
: Entity_Id
) return Boolean;
773 -- If a component size is not static then a warning will be emitted
774 -- in Ravenscar or other restricted contexts. When a component is non-
775 -- static because of a discriminant constraint we can specialize the
776 -- warning by mentioning discriminants explicitly. This was created for
777 -- private components of protected objects, but is generally useful when
778 -- restriction No_Implicit_Heap_Allocation is active.
780 function Effective_Extra_Accessibility
(Id
: Entity_Id
) return Entity_Id
;
781 -- Same as Einfo.Extra_Accessibility except thtat object renames
782 -- are looked through.
784 function Effective_Reads_Enabled
(Id
: Entity_Id
) return Boolean;
785 -- Id should be the entity of a state abstraction, an object, or a type.
786 -- Returns True iff Id is subject to external property Effective_Reads.
788 function Effective_Writes_Enabled
(Id
: Entity_Id
) return Boolean;
789 -- Id should be the entity of a state abstraction, an object, or a type.
790 -- Returns True iff Id is subject to external property Effective_Writes.
792 function Enclosing_Comp_Unit_Node
(N
: Node_Id
) return Node_Id
;
793 -- Returns the enclosing N_Compilation_Unit node that is the root of a
794 -- subtree containing N.
796 function Enclosing_CPP_Parent
(Typ
: Entity_Id
) return Entity_Id
;
797 -- Returns the closest ancestor of Typ that is a CPP type.
799 function Enclosing_Declaration
(N
: Node_Id
) return Node_Id
;
800 -- Returns the declaration node enclosing N (including possibly N itself),
801 -- if any, or Empty otherwise.
803 function Enclosing_Generic_Body
(N
: Node_Id
) return Node_Id
;
804 -- Returns the Node_Id associated with the innermost enclosing generic
805 -- body, if any. If none, then returns Empty.
807 function Enclosing_Generic_Unit
(N
: Node_Id
) return Node_Id
;
808 -- Returns the Node_Id associated with the innermost enclosing generic
809 -- unit, if any. If none, then returns Empty.
811 function Enclosing_HSS
(Stmt
: Node_Id
) return Node_Id
;
812 -- Returns the nearest handled sequence of statements that encloses a given
813 -- statement, or Empty.
815 function Enclosing_Lib_Unit_Entity
816 (E
: Entity_Id
:= Current_Scope
) return Entity_Id
;
817 -- Returns the entity of enclosing library unit node which is the root of
818 -- the current scope (which must not be Standard_Standard, and the caller
819 -- is responsible for ensuring this condition) or other specified entity.
821 function Enclosing_Lib_Unit_Node
(N
: Node_Id
) return Node_Id
;
822 -- Returns the N_Compilation_Unit node of the library unit that is directly
823 -- or indirectly (through a subunit) at the root of a subtree containing
824 -- N. This may be either the same as Enclosing_Comp_Unit_Node, or if
825 -- Enclosing_Comp_Unit_Node returns a subunit, then the corresponding
826 -- library unit. If no such item is found, returns Empty.
828 function Enclosing_Package
(N
: Node_Or_Entity_Id
) return Entity_Id
;
829 -- Utility function to return the Ada entity of the package enclosing
830 -- the entity or node N, if any. Returns Empty if no enclosing package.
832 function Enclosing_Package_Or_Subprogram
(E
: Entity_Id
) return Entity_Id
;
833 -- Returns the entity of the package or subprogram enclosing E, if any.
834 -- Returns Empty if no enclosing package or subprogram.
836 function Enclosing_Subprogram
(N
: Node_Or_Entity_Id
) return Entity_Id
;
837 -- Utility function to return the Ada entity of the subprogram enclosing
838 -- N, if any. Returns Empty if no enclosing subprogram.
840 function End_Keyword_Location
(N
: Node_Id
) return Source_Ptr
;
841 -- Given block statement, entry body, package body, package declaration,
842 -- protected body, [single] protected type declaration, subprogram body,
843 -- task body, or [single] task type declaration N, return the closest
844 -- source location of the "end" keyword.
846 procedure Ensure_Freeze_Node
(E
: Entity_Id
);
847 -- Make sure a freeze node is allocated for entity E. If necessary, build
848 -- and initialize a new freeze node and set Has_Delayed_Freeze True for E.
850 procedure Enter_Name
(Def_Id
: Entity_Id
);
851 -- Insert new name in symbol table of current scope with check for
852 -- duplications (error message is issued if a conflict is found).
853 -- Note: Enter_Name is not used for overloadable entities, instead these
854 -- are entered using Sem_Ch6.Enter_Overloaded_Entity.
856 function Entity_Of
(N
: Node_Id
) return Entity_Id
;
857 -- Obtain the entity of arbitrary node N. If N is a renaming, return the
858 -- entity of the earliest renamed source abstract state or whole object.
859 -- If no suitable entity is available, return Empty. This routine carries
860 -- out actions that are tied to SPARK semantics.
862 function Exceptions_OK
return Boolean;
863 -- Determine whether exceptions are allowed to be caught, propagated, or
866 procedure Explain_Limited_Type
(T
: Entity_Id
; N
: Node_Id
);
867 -- This procedure is called after issuing a message complaining about an
868 -- inappropriate use of limited type T. If useful, it adds additional
869 -- continuation lines to the message explaining why type T is limited.
870 -- Messages are placed at node N.
872 function Expression_Of_Expression_Function
873 (Subp
: Entity_Id
) return Node_Id
;
874 -- Return the expression of expression function Subp
876 type Extensions_Visible_Mode
is
877 (Extensions_Visible_None
,
878 -- Extensions_Visible does not yield a mode when SPARK_Mode is off. This
879 -- value acts as a default in a non-SPARK compilation.
881 Extensions_Visible_False
,
882 -- A value of "False" signifies that Extensions_Visible is either
883 -- missing or the pragma is present and the value of its Boolean
884 -- expression is False.
886 Extensions_Visible_True
);
887 -- A value of "True" signifies that Extensions_Visible is present and
888 -- the value of its Boolean expression is True.
890 function Extensions_Visible_Status
891 (Id
: Entity_Id
) return Extensions_Visible_Mode
;
892 -- Given the entity of a subprogram or formal parameter subject to pragma
893 -- Extensions_Visible, return the Boolean value denoted by the expression
896 procedure Find_Actual
898 Formal
: out Entity_Id
;
900 -- Determines if the node N is an actual parameter of a function or a
901 -- procedure call. If so, then Formal points to the entity for the formal
902 -- (Ekind is E_In_Parameter, E_Out_Parameter, or E_In_Out_Parameter) and
903 -- Call is set to the node for the corresponding call. If the node N is not
904 -- an actual parameter then Formal and Call are set to Empty.
906 function Find_Body_Discriminal
907 (Spec_Discriminant
: Entity_Id
) return Entity_Id
;
908 -- Given a discriminant of the record type that implements a task or
909 -- protected type, return the discriminal of the corresponding discriminant
910 -- of the actual concurrent type.
912 function Find_Corresponding_Discriminant
914 Typ
: Entity_Id
) return Entity_Id
;
915 -- Because discriminants may have different names in a generic unit and in
916 -- an instance, they are resolved positionally when possible. A reference
917 -- to a discriminant carries the discriminant that it denotes when it is
918 -- analyzed. Subsequent uses of this id on a different type denotes the
919 -- discriminant at the same position in this new type.
921 function Find_DIC_Type
(Typ
: Entity_Id
) return Entity_Id
;
922 -- Subsidiary to all Build_DIC_Procedure_xxx routines. Find the type which
923 -- defines the Default_Initial_Condition pragma of type Typ. This is either
924 -- Typ itself or a parent type when the pragma is inherited.
926 function Find_Enclosing_Iterator_Loop
(Id
: Entity_Id
) return Entity_Id
;
927 -- Find the nearest iterator loop which encloses arbitrary entity Id. If
928 -- such a loop exists, return the entity of its identifier (E_Loop scope),
929 -- otherwise return Empty.
931 function Find_Enclosing_Scope
(N
: Node_Id
) return Entity_Id
;
932 -- Find the nearest scope which encloses arbitrary node N
934 function Find_Loop_In_Conditional_Block
(N
: Node_Id
) return Node_Id
;
935 -- Find the nested loop statement in a conditional block. Loops subject to
936 -- attribute 'Loop_Entry are transformed into blocks. Parts of the original
937 -- loop are nested within the block.
939 procedure Find_Overlaid_Entity
943 -- The node N should be an address representation clause. Determines if the
944 -- target expression is the address of an entity with an optional offset.
945 -- If so, set Ent to the entity and, if there is an offset, set Off to
946 -- True, otherwise to False. If it is not possible to determine that the
947 -- address is of this form, then set Ent to Empty.
949 function Find_Parameter_Type
(Param
: Node_Id
) return Entity_Id
;
950 -- Return the type of formal parameter Param as determined by its
953 -- The following type describes the placement of an arbitrary entity with
954 -- respect to SPARK visible / hidden state space.
956 type State_Space_Kind
is
958 -- An entity is not in the visible, private or body state space when
959 -- the immediate enclosing construct is not a package.
962 -- An entity is in the visible state space when it appears immediately
963 -- within the visible declarations of a package or when it appears in
964 -- the visible state space of a nested package which in turn is declared
965 -- in the visible declarations of an enclosing package:
968 -- Visible_Variable : ...
970 -- with Abstract_State => Visible_State
972 -- Visible_Nested_Variable : ...
976 -- Entities associated with a package instantiation inherit the state
977 -- space from the instance placement:
981 -- Generic_Variable : ...
986 -- package Inst is new Gen;
987 -- -- Generic_Variable is in the visible state space of Pack
991 -- An entity is in the private state space when it appears immediately
992 -- within the private declarations of a package or when it appears in
993 -- the visible state space of a nested package which in turn is declared
994 -- in the private declarations of an enclosing package:
998 -- Private_Variable : ...
1000 -- with Abstract_State => Private_State
1002 -- Private_Nested_Variable : ...
1006 -- The same placement principle applies to package instantiations
1009 -- An entity is in the body state space when it appears immediately
1010 -- within the declarations of a package body or when it appears in the
1011 -- visible state space of a nested package which in turn is declared in
1012 -- the declarations of an enclosing package body:
1014 -- package body Pack is
1015 -- Body_Variable : ...
1017 -- with Abstract_State => Body_State
1019 -- Body_Nested_Variable : ...
1023 -- The same placement principle applies to package instantiations
1025 procedure Find_Placement_In_State_Space
1026 (Item_Id
: Entity_Id
;
1027 Placement
: out State_Space_Kind
;
1028 Pack_Id
: out Entity_Id
);
1029 -- Determine the state space placement of an item. Item_Id denotes the
1030 -- entity of an abstract state, object, or package instantiation. Placement
1031 -- captures the precise placement of the item in the enclosing state space.
1032 -- If the state space is that of a package, Pack_Id denotes its entity,
1033 -- otherwise Pack_Id is Empty.
1035 function Find_Primitive_Eq
(Typ
: Entity_Id
) return Entity_Id
;
1036 -- Locate primitive equality for type if it exists. Return Empty if it is
1039 function Find_Specific_Type
(CW
: Entity_Id
) return Entity_Id
;
1040 -- Find specific type of a class-wide type, and handle the case of an
1041 -- incomplete type coming either from a limited_with clause or from an
1042 -- incomplete type declaration. If resulting type is private return its
1045 function Find_Static_Alternative
(N
: Node_Id
) return Node_Id
;
1046 -- N is a case statement whose expression is a compile-time value.
1047 -- Determine the alternative chosen, so that the code of non-selected
1048 -- alternatives, and the warnings that may apply to them, are removed.
1050 function First_Actual
(Node
: Node_Id
) return Node_Id
;
1051 -- Node is an N_Function_Call, N_Procedure_Call_Statement or
1052 -- N_Entry_Call_Statement node. The result returned is the first actual
1053 -- parameter in declaration order (not the order of parameters as they
1054 -- appeared in the source, which can be quite different as a result of the
1055 -- use of named parameters). Empty is returned for a call with no
1056 -- parameters. The procedure for iterating through the actuals in
1057 -- declaration order is to use this function to find the first actual, and
1058 -- then use Next_Actual to obtain the next actual in declaration order.
1059 -- Note that the value returned is always the expression (not the
1060 -- N_Parameter_Association nodes, even if named association is used).
1062 -- WARNING: There is a matching C declaration of this subprogram in fe.h
1064 function First_Global
1066 Global_Mode
: Name_Id
;
1067 Refined
: Boolean := False) return Node_Id
;
1068 -- Returns the first global item of mode Global_Mode (which can be
1069 -- Name_Input, Name_Output, Name_In_Out or Name_Proof_In) associated to
1070 -- subprogram Subp, or Empty otherwise. If Refined is True, the global item
1071 -- is retrieved from the Refined_Global aspect/pragma associated to the
1072 -- body of Subp if present. Next_Global can be used to get the next global
1073 -- item with the same mode.
1075 function Fix_Msg
(Id
: Entity_Id
; Msg
: String) return String;
1076 -- Replace all occurrences of a particular word in string Msg depending on
1077 -- the Ekind of Id as follows:
1078 -- * Replace "subprogram" with
1079 -- - "entry" when Id is an entry [family]
1080 -- - "task type" when Id is a single task object, task type or task
1082 -- * Replace "protected" with
1083 -- - "task" when Id is a single task object, task type or task body
1084 -- All other non-matching words remain as is
1086 function From_Nested_Package
(T
: Entity_Id
) return Boolean;
1087 -- A type declared in a nested package may be frozen by a declaration
1088 -- appearing after the package but before the package is frozen. If the
1089 -- type has aspects that generate subprograms, these may contain references
1090 -- to entities local to the nested package. In that case the package must
1091 -- be installed on the scope stack to prevent spurious visibility errors.
1093 procedure Gather_Components
1095 Comp_List
: Node_Id
;
1096 Governed_By
: List_Id
;
1098 Report_Errors
: out Boolean;
1099 Allow_Compile_Time
: Boolean := False;
1100 Include_Interface_Tag
: Boolean := False);
1101 -- The purpose of this procedure is to gather the valid components in a
1102 -- record type according to the values of its discriminants, in order to
1103 -- validate the components of a record aggregate.
1105 -- Typ is the type of the aggregate when its constrained discriminants
1106 -- need to be collected, otherwise it is Empty.
1108 -- Comp_List is an N_Component_List node.
1110 -- Governed_By is a list of N_Component_Association nodes, where each
1111 -- choice list contains the name of a discriminant and the expression
1112 -- field gives its value. The values of the discriminants governing
1113 -- the (possibly nested) variant parts in Comp_List are found in this
1114 -- Component_Association List.
1116 -- Into is the list where the valid components are appended. Note that
1117 -- Into need not be an Empty list. If it's not, components are attached
1120 -- Report_Errors is set to True if the values of the discriminants are
1121 -- insufficiently static (see body for details of what that means).
1124 -- Allow_Compile_Time if set to True, allows compile time known values in
1125 -- Governed_By expressions in addition to static expressions.
1127 -- Include_Interface_Tag if set to True, gather any interface tag
1128 -- component, otherwise exclude them.
1130 -- This procedure is also used when building a record subtype. If the
1131 -- discriminant constraint of the subtype is static, the components of the
1132 -- subtype are only those of the variants selected by the values of the
1133 -- discriminants. Otherwise all components of the parent must be included
1134 -- in the subtype for semantic analysis.
1136 function Get_Dynamic_Accessibility
(E
: Entity_Id
) return Entity_Id
;
1137 -- Obtain the accessibility level for a given entity formal taking into
1138 -- account both extra and minimum accessibility.
1140 function Get_Actual_Subtype
(N
: Node_Id
) return Entity_Id
;
1141 -- Given a node for an expression, obtain the actual subtype of the
1142 -- expression. In the case of a parameter where the formal is an
1143 -- unconstrained array or discriminated type, this will be the previously
1144 -- constructed subtype of the actual. Note that this is not quite the
1145 -- "Actual Subtype" of the RM, since it is always a constrained type, i.e.
1146 -- it is the subtype of the value of the actual. The actual subtype is also
1147 -- returned in other cases where it has already been constructed for an
1148 -- object. Otherwise the expression type is returned unchanged, except for
1149 -- the case of an unconstrained array type, where an actual subtype is
1150 -- created, using Insert_Actions if necessary to insert any associated
1153 function Get_Actual_Subtype_If_Available
(N
: Node_Id
) return Entity_Id
;
1154 -- This is like Get_Actual_Subtype, except that it never constructs an
1155 -- actual subtype. If an actual subtype is already available, i.e. the
1156 -- Actual_Subtype field of the corresponding entity is set, then it is
1157 -- returned. Otherwise the Etype of the node is returned.
1159 function Get_Body_From_Stub
(N
: Node_Id
) return Node_Id
;
1160 -- Return the body node for a stub
1162 function Get_Cursor_Type
1164 Typ
: Entity_Id
) return Entity_Id
;
1165 -- Find Cursor type in scope of type Typ with Iterable aspect, by locating
1166 -- primitive operation First. For use in resolving the other primitive
1167 -- operations of an Iterable type and expanding loops and quantified
1168 -- expressions over formal containers.
1170 function Get_Cursor_Type
(Typ
: Entity_Id
) return Entity_Id
;
1171 -- Find Cursor type in scope of type Typ with Iterable aspect, by locating
1172 -- primitive operation First. For use after resolving the primitive
1173 -- operations of an Iterable type.
1175 function Get_Default_External_Name
(E
: Node_Or_Entity_Id
) return Node_Id
;
1176 -- This is used to construct the string literal node representing a
1177 -- default external name, i.e. one that is constructed from the name of an
1178 -- entity, or (in the case of extended DEC import/export pragmas) an
1179 -- identifier provided as the external name. Letters in the name are
1180 -- according to the setting of Opt.External_Name_Default_Casing.
1182 function Get_Enclosing_Object
(N
: Node_Id
) return Entity_Id
;
1183 -- If expression N references a part of an object, return this object.
1184 -- Otherwise return Empty. Expression N should have been resolved already.
1186 function Get_Generic_Entity
(N
: Node_Id
) return Entity_Id
;
1187 -- Returns the true generic entity in an instantiation. If the name in the
1188 -- instantiation is a renaming, the function returns the renamed generic.
1190 function Get_Incomplete_View_Of_Ancestor
(E
: Entity_Id
) return Entity_Id
;
1191 -- Implements the notion introduced ever-so briefly in RM 7.3.1 (5.2/3):
1192 -- in a child unit a derived type is within the derivation class of an
1193 -- ancestor declared in a parent unit, even if there is an intermediate
1194 -- derivation that does not see the full view of that ancestor.
1196 procedure Get_Index_Bounds
1200 Use_Full_View
: Boolean := False);
1201 -- This procedure assigns to L and H respectively the values of the low and
1202 -- high bounds of node N, which must be a range, subtype indication, or the
1203 -- name of a scalar subtype. The result in L, H may be set to Error if
1204 -- there was an earlier error in the range.
1205 -- Use_Full_View is intended for use by clients other than the compiler
1206 -- (specifically, gnat2scil) to indicate that we want the full view if
1207 -- the index type turns out to be a partial view; this case should not
1208 -- arise during normal compilation of semantically correct programs.
1210 type Range_Nodes
is record
1211 First
, Last
: Node_Id
; -- First and Last nodes of a discrete_range
1214 type Range_Values
is record
1215 First
, Last
: Uint
; -- First and Last values of a discrete_range
1218 function Get_Index_Bounds
1220 Use_Full_View
: Boolean := False) return Range_Nodes
;
1221 -- Same as the above procedure, but returns the result as a record.
1222 -- ???This should probably replace the procedure.
1224 function Get_Index_Bounds
1226 Use_Full_View
: Boolean := False) return Range_Values
;
1227 -- Same as the above function, but returns the values, which must be known
1230 procedure Get_Interfacing_Aspects
1231 (Iface_Asp
: Node_Id
;
1232 Conv_Asp
: out Node_Id
;
1233 EN_Asp
: out Node_Id
;
1234 Expo_Asp
: out Node_Id
;
1235 Imp_Asp
: out Node_Id
;
1236 LN_Asp
: out Node_Id
;
1237 Do_Checks
: Boolean := False);
1238 -- Given a single interfacing aspect Iface_Asp, retrieve other interfacing
1239 -- aspects that apply to the same related entity. The aspects considered by
1240 -- this routine are as follows:
1242 -- Conv_Asp - aspect Convention
1243 -- EN_Asp - aspect External_Name
1244 -- Expo_Asp - aspect Export
1245 -- Imp_Asp - aspect Import
1246 -- LN_Asp - aspect Link_Name
1248 -- When flag Do_Checks is set, this routine will flag duplicate uses of
1251 function Get_Enum_Lit_From_Pos
1254 Loc
: Source_Ptr
) return Node_Id
;
1255 -- This function returns an identifier denoting the E_Enumeration_Literal
1256 -- entity for the specified value from the enumeration type or subtype T.
1257 -- The second argument is the Pos value. Constraint_Error is raised if
1258 -- argument Pos is not in range. The third argument supplies a source
1259 -- location for constructed nodes returned by this function. If No_Location
1260 -- is supplied as source location, the location of the returned node is
1261 -- copied from the original source location for the enumeration literal,
1264 function Get_Iterable_Type_Primitive
1266 Nam
: Name_Id
) return Entity_Id
;
1267 -- Retrieve one of the primitives First, Last, Next, Previous, Has_Element,
1268 -- Element from the value of the Iterable aspect of a type.
1270 function Get_Library_Unit_Name
(Decl_Node
: Node_Id
) return String_Id
;
1271 -- Return the full expanded name of the library unit declared by Decl_Node
1273 function Get_Max_Queue_Length
(Id
: Entity_Id
) return Uint
;
1274 -- Return the argument of pragma Max_Queue_Length or zero if the annotation
1275 -- is not present. It is assumed that Id denotes an entry.
1277 function Get_Name_Entity_Id
(Id
: Name_Id
) return Entity_Id
;
1278 pragma Inline
(Get_Name_Entity_Id
);
1279 -- An entity value is associated with each name in the name table. The
1280 -- Get_Name_Entity_Id function fetches the Entity_Id of this entity, which
1281 -- is the innermost visible entity with the given name. See the body of
1282 -- Sem_Ch8 for further details on handling of entity visibility.
1284 function Get_Name_From_CTC_Pragma
(N
: Node_Id
) return String_Id
;
1285 -- Return the Name component of Test_Case pragma N
1286 -- Bad name now that this no longer applies to Contract_Case ???
1288 function Get_Parent_Entity
(Unit
: Node_Id
) return Entity_Id
;
1289 -- Get defining entity of parent unit of a child unit. In most cases this
1290 -- is the defining entity of the unit, but for a child instance whose
1291 -- parent needs a body for inlining, the instantiation node of the parent
1292 -- has not yet been rewritten as a package declaration, and the entity has
1293 -- to be retrieved from the Instance_Spec of the unit.
1295 function Get_Pragma_Id
(N
: Node_Id
) return Pragma_Id
;
1296 pragma Inline
(Get_Pragma_Id
);
1297 -- Obtains the Pragma_Id from Pragma_Name_Unmapped (N)
1299 function Get_Qualified_Name
1301 Suffix
: Entity_Id
:= Empty
) return Name_Id
;
1302 -- Obtain the fully qualified form of entity Id. The format is:
1303 -- scope_of_id-1__scope_of_id__chars_of_id__chars_of_suffix
1305 function Get_Qualified_Name
1307 Suffix
: Name_Id
:= No_Name
;
1308 Scop
: Entity_Id
:= Current_Scope
) return Name_Id
;
1309 -- Obtain the fully qualified form of name Nam assuming it appears in scope
1310 -- Scop. The format is:
1311 -- scop-1__scop__nam__suffix
1313 procedure Get_Reason_String
(N
: Node_Id
);
1314 -- Recursive routine to analyze reason argument for pragma Warnings. The
1315 -- value of the reason argument is appended to the current string using
1316 -- Store_String_Chars. The reason argument is expected to be a string
1317 -- literal or concatenation of string literals. An error is given for
1320 function Get_Reference_Discriminant
(Typ
: Entity_Id
) return Entity_Id
;
1321 -- If Typ has Implicit_Dereference, return discriminant specified in the
1322 -- corresponding aspect.
1324 function Get_Referenced_Object
(N
: Node_Id
) return Node_Id
;
1325 -- Given an arbitrary node, return the renamed object if the node
1326 -- represents a renamed object; otherwise return the node unchanged.
1327 -- The node can represent an arbitrary expression or any other kind of
1328 -- node (such as the name of a type).
1330 function Get_Renamed_Entity
(E
: Entity_Id
) return Entity_Id
;
1331 -- Given an entity for an exception, package, subprogram or generic unit,
1332 -- returns the ultimately renamed entity if this is a renaming. If this is
1333 -- not a renamed entity, returns its argument. It is an error to call this
1334 -- with any other kind of entity.
1336 function Get_Return_Object
(N
: Node_Id
) return Entity_Id
;
1337 -- Given an extended return statement, return the corresponding return
1338 -- object, identified as the one for which Is_Return_Object = True.
1340 function Get_Subprogram_Entity
(Nod
: Node_Id
) return Entity_Id
;
1341 -- Nod is either a procedure call statement, or a function call, or an
1342 -- accept statement node. This procedure finds the Entity_Id of the related
1343 -- subprogram or entry and returns it, or if no subprogram can be found,
1346 function Get_Task_Body_Procedure
(E
: Entity_Id
) return Entity_Id
;
1347 -- Given an entity for a task type or subtype, retrieves the
1348 -- Task_Body_Procedure field from the corresponding task type declaration.
1350 function Get_User_Defined_Equality
(E
: Entity_Id
) return Entity_Id
;
1351 -- For a type entity, return the entity of the primitive equality function
1352 -- for the type if it exists, otherwise return Empty.
1356 Priv_Typ
: out Entity_Id
;
1357 Full_Typ
: out Entity_Id
;
1358 UFull_Typ
: out Entity_Id
;
1359 CRec_Typ
: out Entity_Id
);
1360 -- Obtain the partial and full views of type Typ and in addition any extra
1361 -- types the full views may have. The return entities are as follows:
1363 -- Priv_Typ - the partial view (a private type)
1364 -- Full_Typ - the full view
1365 -- UFull_Typ - the underlying full view, if the full view is private
1366 -- CRec_Typ - the corresponding record type of the full views
1368 function Get_Fullest_View
1370 Include_PAT
: Boolean := True;
1371 Recurse
: Boolean := True) return Entity_Id
;
1372 -- Get the fullest possible view of E, looking through private, limited,
1373 -- packed array and other implementation types. If Include_PAT is False,
1374 -- don't look inside packed array types. If Recurse is False, just
1375 -- go down one level (so it's no longer the "fullest" view).
1377 function Has_Access_Values
(T
: Entity_Id
) return Boolean;
1378 -- Returns true if the underlying type of T is an access type, or has a
1379 -- component (at any recursive level) that is an access type. This is a
1380 -- conservative predicate, if it is not known whether or not T contains
1381 -- access values (happens for generic formals in some cases), then False is
1382 -- returned. Note that tagged types return False. Even though the tag is
1383 -- implemented as an access type internally, this function tests only for
1384 -- access types known to the programmer. See also Has_Tagged_Component.
1386 function Has_Anonymous_Access_Discriminant
(Typ
: Entity_Id
) return Boolean;
1387 -- Returns True if Typ has one or more anonymous access discriminants
1389 type Alignment_Result
is (Known_Compatible
, Unknown
, Known_Incompatible
);
1390 -- Result of Has_Compatible_Alignment test, description found below. Note
1391 -- that the values are arranged in increasing order of problematicness.
1393 function Has_Compatible_Alignment
1396 Layout_Done
: Boolean) return Alignment_Result
;
1397 -- Obj is an object entity, and expr is a node for an object reference. If
1398 -- the alignment of the object referenced by Expr is known to be compatible
1399 -- with the alignment of Obj (i.e. is larger or the same), then the result
1400 -- is Known_Compatible. If the alignment of the object referenced by Expr
1401 -- is known to be less than the alignment of Obj, then Known_Incompatible
1402 -- is returned. If neither condition can be reliably established at compile
1403 -- time, then Unknown is returned. If Layout_Done is True, the function can
1404 -- assume that the information on size and alignment of types and objects
1405 -- is present in the tree. This is used to determine if alignment checks
1406 -- are required for address clauses (Layout_Done is False in this case) as
1407 -- well as to issue appropriate warnings for them in the post compilation
1408 -- phase (Layout_Done is True in this case).
1410 -- Note: Known_Incompatible does not mean that at run time the alignment
1411 -- of Expr is known to be wrong for Obj, just that it can be determined
1412 -- that alignments have been explicitly or implicitly specified which are
1413 -- incompatible (whereas Unknown means that even this is not known). The
1414 -- appropriate reaction of a caller to Known_Incompatible is to treat it as
1415 -- Unknown, but issue a warning that there may be an alignment error.
1417 function Has_Declarations
(N
: Node_Id
) return Boolean;
1418 -- Determines if the node can have declarations
1420 function Has_Defaulted_Discriminants
(Typ
: Entity_Id
) return Boolean;
1421 -- Simple predicate to test for defaulted discriminants
1423 function Has_Denormals
(E
: Entity_Id
) return Boolean;
1424 -- Determines if the floating-point type E supports denormal numbers.
1425 -- Returns False if E is not a floating-point type.
1427 function Has_Discriminant_Dependent_Constraint
1428 (Comp
: Entity_Id
) return Boolean;
1429 -- Returns True if and only if Comp has a constrained subtype that depends
1430 -- on a discriminant.
1432 function Has_Effectively_Volatile_Profile
1433 (Subp_Id
: Entity_Id
) return Boolean;
1434 -- Determine whether subprogram Subp_Id has an effectively volatile formal
1435 -- parameter for reading or returns an effectively volatile value for
1438 function Has_Full_Default_Initialization
(Typ
: Entity_Id
) return Boolean;
1439 -- Determine whether type Typ defines "full default initialization" as
1440 -- specified by SPARK RM 3.1. To qualify as such, the type must be
1441 -- * A scalar type with specified Default_Value
1442 -- * An array-of-scalar type with specified Default_Component_Value
1443 -- * An array type whose element type defines full default initialization
1444 -- * A protected type, record type or type extension whose components
1445 -- either include a default expression or have a type which defines
1446 -- full default initialization. In the case of type extensions, the
1447 -- parent type defines full default initialization.
1449 -- * A private type with pragma Default_Initial_Condition that provides
1450 -- full default initialization.
1451 -- This function is not used in GNATprove anymore, but is used in CodePeer.
1453 function Has_Fully_Default_Initializing_DIC_Pragma
1454 (Typ
: Entity_Id
) return Boolean;
1455 -- Determine whether type Typ has a suitable Default_Initial_Condition
1456 -- pragma which provides the full default initialization of the type.
1458 function Has_Inferable_Discriminants
(N
: Node_Id
) return Boolean;
1459 -- Ada 2005 (AI-216): A view of an Unchecked_Union object has inferable
1460 -- discriminants if it has a constrained nominal type, unless the object
1461 -- is a component of an enclosing Unchecked_Union object that is subject
1462 -- to a per-object constraint and the enclosing object lacks inferable
1465 -- An expression of an Unchecked_Union type has inferable discriminants
1466 -- if it is either a name of an object with inferable discriminants or a
1467 -- qualified expression whose subtype mark denotes a constrained subtype.
1469 function Has_Infinities
(E
: Entity_Id
) return Boolean;
1470 -- Determines if the range of the floating-point type E includes
1471 -- infinities. Returns False if E is not a floating-point type.
1473 function Has_Interfaces
1475 Use_Full_View
: Boolean := True) return Boolean;
1476 -- Where T is a concurrent type or a record type, returns true if T covers
1477 -- any abstract interface types. In case of private types the argument
1478 -- Use_Full_View controls if the check is done using its full view (if
1481 function Has_Max_Queue_Length
(Id
: Entity_Id
) return Boolean;
1482 -- Determine whether Id is subject to pragma Max_Queue_Length. It is
1483 -- assumed that Id denotes an entry.
1485 function Has_No_Obvious_Side_Effects
(N
: Node_Id
) return Boolean;
1486 -- This is a simple minded function for determining whether an expression
1487 -- has no obvious side effects. It is used only for determining whether
1488 -- warnings are needed in certain situations, and is not guaranteed to
1489 -- be accurate in either direction. Exceptions may mean an expression
1490 -- does in fact have side effects, but this may be ignored and True is
1491 -- returned, or a complex expression may in fact be side effect free
1492 -- but we don't recognize it here and return False. The Side_Effect_Free
1493 -- routine in Remove_Side_Effects is much more extensive and perhaps could
1494 -- be shared, so that this routine would be more accurate.
1496 function Has_Non_Null_Refinement
(Id
: Entity_Id
) return Boolean;
1497 -- Determine whether abstract state Id has at least one nonnull constituent
1498 -- as expressed in pragma Refined_State. This function does not take into
1499 -- account the visible refinement region of abstract state Id.
1501 function Has_Non_Trivial_Precondition
(Subp
: Entity_Id
) return Boolean;
1502 -- Determine whether subprogram Subp has a class-wide precondition that is
1503 -- not statically True.
1505 function Has_Null_Body
(Proc_Id
: Entity_Id
) return Boolean;
1506 -- Determine whether the body of procedure Proc_Id contains a sole null
1507 -- statement, possibly followed by an optional return. Used to optimize
1508 -- useless calls to assertion checks.
1510 function Has_Null_Exclusion
(N
: Node_Id
) return Boolean;
1511 -- Determine whether node N has a null exclusion
1513 function Has_Null_Refinement
(Id
: Entity_Id
) return Boolean;
1514 -- Determine whether abstract state Id has a null refinement as expressed
1515 -- in pragma Refined_State. This function does not take into account the
1516 -- visible refinement region of abstract state Id.
1518 function Has_Non_Null_Statements
(L
: List_Id
) return Boolean;
1519 -- Return True if L has non-null statements
1521 function Side_Effect_Free_Statements
(L
: List_Id
) return Boolean;
1522 -- Return True if L has no statements with side effects
1524 function Side_Effect_Free_Loop
(N
: Node_Id
) return Boolean;
1525 -- Return True if the loop has no side effect and can therefore be
1526 -- marked for removal. Return False if N is not a N_Loop_Statement.
1528 subtype Static_Accessibility_Level_Kind
1529 is Accessibility_Level_Kind
range Object_Decl_Level
1530 .. Zero_On_Dynamic_Level
;
1531 -- Restrict the reange of Accessibility_Level_Kind to be non-dynamic for
1532 -- use in the static version of Accessibility_Level below.
1534 function Static_Accessibility_Level
1536 Level
: Static_Accessibility_Level_Kind
;
1537 In_Return_Context
: Boolean := False) return Uint
;
1538 -- Overloaded version of Accessibility_Level which returns a universal
1539 -- integer for use in compile-time checking. Note: Level is restricted to
1542 function Is_Newly_Constructed
1543 (Exp
: Node_Id
; Context_Requires_NC
: Boolean) return Boolean;
1544 -- Indicates whether a given expression is "newly constructed" (RM 4.4).
1545 -- Context_Requires_NC determines the result returned for cases like a
1546 -- raise expression or a conditional expression where some-but-not-all
1547 -- operative constituents are newly constructed. Thus, this is a
1548 -- somewhat unusual predicate in that the result required in order to
1549 -- satisfy whatever legality rule is being checked can influence the
1550 -- result of the predicate. Context_Requires_NC might be True for
1551 -- something like the "newly constructed" rule for a limited expression
1552 -- of a return statement, and False for something like the
1553 -- "newly constructed" rule pertaining to a limited object renaming in a
1554 -- declare expression. Eventually, the code to implement every
1555 -- RM legality rule requiring/prohibiting a "newly constructed" expression
1556 -- should be implemented by calling this function; that's not done yet.
1557 -- The function name doesn't quite match the RM definition of the term if
1558 -- Context_Requires_NC = False; in that case, "Might_Be_Newly_Constructed"
1559 -- might be a more accurate name.
1561 function Is_Prim_Of_Abst_Type_With_Nonstatic_CW_Pre_Post
1562 (Subp
: Entity_Id
) return Boolean;
1563 -- Return True if Subp is a primitive of an abstract type, where the
1564 -- primitive has a class-wide pre- or postcondition whose expression
1567 function Has_Overriding_Initialize
(T
: Entity_Id
) return Boolean;
1568 -- Predicate to determine whether a controlled type has a user-defined
1569 -- Initialize primitive (and, in Ada 2012, whether that primitive is
1570 -- non-null), which causes the type to not have preelaborable
1573 function Has_Preelaborable_Initialization
1575 Preelab_Init_Expr
: Node_Id
:= Empty
) return Boolean;
1576 -- Return True iff type E has preelaborable initialization as defined in
1577 -- Ada 2005 (see AI-161 for details of the definition of this attribute).
1578 -- If Preelab_Init_Expr is present, indicates that the function should
1579 -- presume that for any subcomponent of E that is of a formal private or
1580 -- derived type that is referenced by a Preelaborable_Initialization
1581 -- attribute within the expression Preelab_Init_Expr, the formal type has
1582 -- preelaborable initialization (RM 10.2.1(11.8/5) and AI12-0409).
1584 function Has_Prefix
(N
: Node_Id
) return Boolean;
1585 -- Return True if N has attribute Prefix
1587 function Has_Private_Component
(Type_Id
: Entity_Id
) return Boolean;
1588 -- Check if a type has a (sub)component of a private type that has not
1589 -- yet received a full declaration.
1591 function Has_Relaxed_Initialization
(E
: Entity_Id
) return Boolean;
1592 -- Returns True iff entity E is subject to the Relaxed_Initialization
1593 -- aspect. Entity E can be either type, variable, constant, subprogram,
1594 -- entry or an abstract state. For private types and deferred constants
1595 -- E should be the private view, because aspect can only be attached there.
1597 function Has_Signed_Zeros
(E
: Entity_Id
) return Boolean;
1598 -- Determines if the floating-point type E supports signed zeros.
1599 -- Returns False if E is not a floating-point type.
1601 function Has_Significant_Contract
(Subp_Id
: Entity_Id
) return Boolean;
1602 -- Determine whether subprogram [body] Subp_Id has a significant contract.
1603 -- All subprograms have a N_Contract node, but this does not mean that the
1604 -- contract is useful.
1606 function Has_Static_Array_Bounds
(Typ
: Node_Id
) return Boolean;
1607 -- Return whether an array type has static bounds
1609 function Has_Static_Non_Empty_Array_Bounds
(Typ
: Node_Id
) return Boolean;
1610 -- Determine whether array type Typ has static non-empty bounds
1612 function Has_Stream
(T
: Entity_Id
) return Boolean;
1613 -- Tests if type T is derived from Ada.Streams.Root_Stream_Type, or in the
1614 -- case of a composite type, has a component for which this predicate is
1615 -- True, and if so returns True. Otherwise a result of False means that
1616 -- there is no Stream type in sight. For a private type, the test is
1617 -- applied to the underlying type (or returns False if there is no
1618 -- underlying type).
1620 function Has_Suffix
(E
: Entity_Id
; Suffix
: Character) return Boolean;
1621 -- Returns true if the last character of E is Suffix. Used in Assertions.
1623 function Has_Tagged_Component
(Typ
: Entity_Id
) return Boolean;
1624 -- Returns True if Typ is a composite type (array or record) that is either
1625 -- a tagged type or has a subcomponent that is tagged. Returns False for a
1626 -- noncomposite type, or if no tagged subcomponents are present.
1628 function Has_Unconstrained_Access_Discriminants
1629 (Subtyp
: Entity_Id
) return Boolean;
1630 -- Returns True if the given subtype is unconstrained and has one or more
1631 -- access discriminants.
1633 function Has_Undefined_Reference
(Expr
: Node_Id
) return Boolean;
1634 -- Given arbitrary expression Expr, determine whether it contains at
1635 -- least one name whose entity is Any_Id.
1637 function Has_Volatile_Component
(Typ
: Entity_Id
) return Boolean;
1638 -- Given arbitrary type Typ, determine whether it contains at least one
1639 -- volatile component.
1641 function Implementation_Kind
(Subp
: Entity_Id
) return Name_Id
;
1642 -- Subp is a subprogram marked with pragma Implemented. Return the specific
1643 -- implementation requirement which the pragma imposes. The return value is
1644 -- either Name_By_Any, Name_By_Entry or Name_By_Protected_Procedure.
1646 function Implements_Interface
1647 (Typ_Ent
: Entity_Id
;
1648 Iface_Ent
: Entity_Id
;
1649 Exclude_Parents
: Boolean := False) return Boolean;
1650 -- Returns true if the Typ_Ent implements interface Iface_Ent
1652 function Implicitly_Designated_Type
(Typ
: Entity_Id
) return Entity_Id
;
1653 -- Called when Typ is the type of the prefix of an implicit dereference.
1654 -- Return the designated type of Typ, taking into account that this type
1655 -- may be a limited view, when the nonlimited view is visible.
1657 function In_Assertion_Expression_Pragma
(N
: Node_Id
) return Boolean;
1658 -- Returns True if node N appears within a pragma that acts as an assertion
1659 -- expression. See Sem_Prag for the list of qualifying pragmas.
1661 function In_Check_Node
(N
: Node_Id
) return Boolean;
1662 -- Return True if N is part of a N_Raise_xxx_Error node
1664 function In_Generic_Formal_Package
(E
: Entity_Id
) return Boolean;
1665 -- Returns True if entity E is inside a generic formal package
1667 function In_Generic_Scope
(E
: Entity_Id
) return Boolean;
1668 -- Returns True if entity E is inside a generic scope
1670 function In_Instance
return Boolean;
1671 -- Returns True if the current scope is within a generic instance
1673 function In_Instance_Body
return Boolean;
1674 -- Returns True if current scope is within the body of an instance, where
1675 -- several semantic checks (e.g. accessibility checks) are relaxed.
1677 function In_Instance_Not_Visible
return Boolean;
1678 -- Returns True if current scope is with the private part or the body of
1679 -- an instance. Other semantic checks are suppressed in this context.
1681 function In_Instance_Visible_Part
1682 (Id
: Entity_Id
:= Current_Scope
) return Boolean;
1683 -- Returns True if arbitrary entity Id is within the visible part of a
1684 -- package instance, where several additional semantic checks apply.
1686 function In_Package_Body
return Boolean;
1687 -- Returns True if current scope is within a package body
1689 function In_Pragma_Expression
(N
: Node_Id
; Nam
: Name_Id
) return Boolean;
1690 -- Returns true if the expression N occurs within a pragma with name Nam
1692 function In_Pre_Post_Condition
1693 (N
: Node_Id
; Class_Wide_Only
: Boolean := False) return Boolean;
1694 -- Returns True if node N appears within a pre/postcondition pragma. Note
1695 -- the pragma Check equivalents are NOT considered. If Class_Wide_Only is
1696 -- True, then tests for N appearing within a class-wide pre/postcondition.
1698 function In_Quantified_Expression
(N
: Node_Id
) return Boolean;
1699 -- Returns true if the expression N occurs within a quantified expression
1701 function In_Return_Value
(Expr
: Node_Id
) return Boolean;
1702 -- Returns true if the expression Expr occurs within a simple return
1703 -- statement or is part of an assignment to the return object in an
1704 -- extended return statement.
1706 function In_Reverse_Storage_Order_Object
(N
: Node_Id
) return Boolean;
1707 -- Returns True if N denotes a component or subcomponent in a record or
1708 -- array that has Reverse_Storage_Order.
1710 function In_Same_Declarative_Part
1712 N
: Node_Id
) return Boolean;
1713 -- True if the node N appears within the same declarative part denoted by
1714 -- the node Context.
1716 function In_Subprogram_Or_Concurrent_Unit
return Boolean;
1717 -- Determines if the current scope is within a subprogram compilation unit
1718 -- (inside a subprogram declaration, subprogram body, or generic subprogram
1719 -- declaration) or within a task or protected body. The test is for
1720 -- appearing anywhere within such a construct (that is it does not need
1721 -- to be directly within).
1723 function In_Subtree
(N
: Node_Id
; Root
: Node_Id
) return Boolean;
1724 -- Determine whether node N is within the subtree rooted at Root
1729 Root2
: Node_Id
) return Boolean;
1730 -- Determine whether node N is within the subtree rooted at Root1 or Root2.
1731 -- This version is more efficient than calling the single root version of
1732 -- Is_Subtree twice.
1734 function In_Statement_Condition_With_Actions
(N
: Node_Id
) return Boolean;
1735 -- Returns true if the expression N occurs within the condition of a
1736 -- statement node with actions. Subsidiary to inlining for GNATprove, where
1737 -- inlining of function calls in such expressions would expand the called
1738 -- body into actions list of the condition node. GNATprove cannot yet cope
1739 -- with such a complex AST.
1741 function In_Visible_Part
(Scope_Id
: Entity_Id
) return Boolean;
1742 -- Determine whether a declaration occurs within the visible part of a
1743 -- package specification. The package must be on the scope stack, and the
1744 -- corresponding private part must not.
1746 function Incomplete_Or_Partial_View
(Id
: Entity_Id
) return Entity_Id
;
1747 -- Given the entity of a constant or a type, retrieve the incomplete or
1748 -- partial view of the same entity. Note that Id may not have a partial
1749 -- view in which case the function returns Empty.
1751 function Incomplete_View_From_Limited_With
1752 (Typ
: Entity_Id
) return Entity_Id
;
1753 -- Typ is a type entity. This normally returns Typ. However, if there is
1754 -- an incomplete view of this entity that comes from a limited-with'ed
1755 -- package, then this returns that incomplete view.
1757 function Indexed_Component_Bit_Offset
(N
: Node_Id
) return Uint
;
1758 -- Given an N_Indexed_Component node, return the first bit position of the
1759 -- component if it is known at compile time. A value of No_Uint means that
1760 -- either the value is not yet known before back-end processing or it is
1761 -- not known at compile time after back-end processing.
1763 procedure Inherit_Predicate_Flags
(Subt
, Par
: Entity_Id
);
1764 -- Propagate static and dynamic predicate flags from a parent to the
1765 -- subtype in a subtype declaration with and without constraints.
1767 procedure Inherit_Rep_Item_Chain
(Typ
: Entity_Id
; From_Typ
: Entity_Id
);
1768 -- Inherit the rep item chain of type From_Typ without clobbering any
1769 -- existing rep items on Typ's chain. Typ is the destination type.
1771 function Inherits_From_Tagged_Full_View
(Typ
: Entity_Id
) return Boolean;
1772 pragma Inline
(Inherits_From_Tagged_Full_View
);
1773 -- Return True if Typ is an untagged private type completed with a
1774 -- derivation of an untagged private type declaration whose full view
1775 -- is a tagged type.
1777 procedure Insert_Explicit_Dereference
(N
: Node_Id
);
1778 -- In a context that requires a composite or subprogram type and where a
1779 -- prefix is an access type, rewrite the access type node N (which is the
1780 -- prefix, e.g. of an indexed component) as an explicit dereference.
1782 procedure Inspect_Deferred_Constant_Completion
(Decls
: List_Id
);
1783 -- Examine all deferred constants in the declaration list Decls and check
1784 -- whether they have been completed by a full constant declaration or an
1785 -- Import pragma. Emit the error message if that is not the case.
1787 procedure Install_Elaboration_Model
(Unit_Id
: Entity_Id
);
1788 -- Install the elaboration model specified by pragma Elaboration_Checks
1789 -- associated with compilation unit Unit_Id. No action is taken when the
1790 -- unit lacks such pragma.
1792 procedure Install_Generic_Formals
(Subp_Id
: Entity_Id
);
1793 -- Install both the generic formal parameters and the formal parameters of
1794 -- generic subprogram Subp_Id into visibility.
1796 procedure Install_SPARK_Mode
(Mode
: SPARK_Mode_Type
; Prag
: Node_Id
);
1797 -- Establish the SPARK_Mode and SPARK_Mode_Pragma currently in effect
1799 function Invalid_Scalar_Value
1801 Scal_Typ
: Scalar_Id
) return Node_Id
;
1802 -- Obtain the invalid value for scalar type Scal_Typ as either specified by
1803 -- pragma Initialize_Scalars or by the binder. Return an expression created
1804 -- at source location Loc, which denotes the invalid value.
1806 function Is_Anonymous_Access_Actual
(N
: Node_Id
) return Boolean;
1807 -- Determine if N is used as an actual for a call whose corresponding
1808 -- formal is of an anonymous access type.
1810 function Is_Access_Subprogram_Wrapper
(E
: Entity_Id
) return Boolean;
1811 -- True if E is the constructed wrapper for an access_to_subprogram
1812 -- type with Pre/Postconditions.
1814 function Is_Access_Variable
(E
: Entity_Id
) return Boolean;
1815 -- Determines if type E is an access-to-variable
1817 function Is_Actual_In_Out_Parameter
(N
: Node_Id
) return Boolean;
1818 -- Determines if N is an actual parameter of in-out mode in a subprogram
1821 function Is_Actual_Out_Parameter
(N
: Node_Id
) return Boolean;
1822 -- Determines if N is an actual parameter of out mode in a subprogram call
1824 function Is_Actual_Out_Or_In_Out_Parameter
(N
: Node_Id
) return Boolean;
1825 -- Determines if N is an actual parameter of out or in out mode in a
1828 function Is_Actual_Parameter
(N
: Node_Id
) return Boolean;
1829 -- Determines if N is an actual parameter in a subprogram or entry call
1831 function Is_Actual_Tagged_Parameter
(N
: Node_Id
) return Boolean;
1832 -- Determines if N is an actual parameter of a formal of tagged type in a
1835 function Is_Aliased_View
(Obj
: Node_Id
) return Boolean;
1836 -- Determine if Obj is an aliased view, i.e. the name of an object to which
1837 -- 'Access or 'Unchecked_Access can apply. Note that this routine uses the
1838 -- rules of the language, it does not take into account the restriction
1839 -- No_Implicit_Aliasing, so it can return True if the restriction is active
1840 -- and Obj violates the restriction. The caller is responsible for calling
1841 -- Restrict.Check_No_Implicit_Aliasing if True is returned, but there is a
1842 -- requirement for obeying the restriction in the call context.
1844 function Is_Ancestor_Package
1846 E2
: Entity_Id
) return Boolean;
1847 -- Determine whether package E1 is an ancestor of E2
1849 function Is_Atomic_Object
(N
: Node_Id
) return Boolean;
1850 -- Determine whether arbitrary node N denotes a reference to an atomic
1851 -- object as per RM C.6(7) and the crucial remark in RM C.6(8).
1853 function Is_Attribute_Loop_Entry
(N
: Node_Id
) return Boolean;
1854 -- Determine whether node N denotes attribute 'Loop_Entry
1856 function Is_Attribute_Old
(N
: Node_Id
) return Boolean;
1857 -- Determine whether node N denotes attribute 'Old
1859 function Is_Attribute_Result
(N
: Node_Id
) return Boolean;
1860 -- Determine whether node N denotes attribute 'Result
1862 function Is_Attribute_Update
(N
: Node_Id
) return Boolean;
1863 -- Determine whether node N denotes attribute 'Update
1865 function Is_Body_Or_Package_Declaration
(N
: Node_Id
) return Boolean;
1866 -- Determine whether node N denotes a body or a package declaration
1868 function Is_Bounded_String
(T
: Entity_Id
) return Boolean;
1869 -- True if T is a bounded string type. Used to make sure "=" composes
1870 -- properly for bounded string types.
1872 function Is_By_Protected_Procedure
(Id
: Entity_Id
) return Boolean;
1873 -- Determine whether entity Id denotes a procedure with synchronization
1874 -- kind By_Protected_Procedure.
1876 function Is_Confirming
(Aspect
: Nonoverridable_Aspect_Id
;
1877 Aspect_Spec_1
, Aspect_Spec_2
: Node_Id
)
1879 -- Returns true if the two specifications of the given
1880 -- nonoverridable aspect are compatible.
1882 function Is_Conjunction_Of_Formal_Preelab_Init_Attributes
1883 (Expr
: Node_Id
) return Boolean;
1884 -- Returns True if Expr is a Preelaborable_Initialization attribute applied
1885 -- to a formal type, or a sequence of two or more such attributes connected
1886 -- by "and" operators, or if the Original_Node of Expr or its constituents
1887 -- is such an attribute.
1889 function Is_Constant_Bound
(Exp
: Node_Id
) return Boolean;
1890 -- Exp is the expression for an array bound. Determines whether the
1891 -- bound is a compile-time known value, or a constant entity, or an
1892 -- enumeration literal, or an expression composed of constant-bound
1893 -- subexpressions which are evaluated by means of standard operators.
1895 function Is_Container_Element
(Exp
: Node_Id
) return Boolean;
1896 -- This routine recognizes expressions that denote an element of one of
1897 -- the predefined containers, when the source only contains an indexing
1898 -- operation and an implicit dereference is inserted by the compiler.
1899 -- In the absence of this optimization, the indexing creates a temporary
1900 -- controlled cursor that sets the tampering bit of the container, and
1901 -- restricts the use of the convenient notation C (X) to contexts that
1902 -- do not check the tampering bit (e.g. C.Include (X, C (Y)). Exp is an
1903 -- explicit dereference. The transformation applies when it has the form
1906 function Is_Contract_Annotation
(Item
: Node_Id
) return Boolean;
1907 -- Determine whether aspect specification or pragma Item is a contract
1910 function Is_Controlling_Limited_Procedure
1911 (Proc_Nam
: Entity_Id
) return Boolean;
1912 -- Ada 2005 (AI-345): Determine whether Proc_Nam is a primitive procedure
1913 -- of a limited interface with a controlling first parameter.
1915 function Is_CPP_Constructor_Call
(N
: Node_Id
) return Boolean;
1916 -- Returns True if N is a call to a CPP constructor
1918 function Is_CCT_Instance
1919 (Ref_Id
: Entity_Id
;
1920 Context_Id
: Entity_Id
) return Boolean;
1921 -- Subsidiary to the analysis of pragmas [Refined_]Depends and [Refined_]
1922 -- Global; also used when analyzing default expressions of protected and
1923 -- record components. Determine whether entity Ref_Id (which must represent
1924 -- either a protected type or a task type) denotes the current instance of
1925 -- a concurrent type. Context_Id denotes the associated context where the
1928 function Is_Child_Or_Sibling
1929 (Pack_1
: Entity_Id
;
1930 Pack_2
: Entity_Id
) return Boolean;
1931 -- Determine the following relations between two arbitrary packages:
1932 -- 1) One package is the parent of a child package
1933 -- 2) Both packages are siblings and share a common parent
1935 function Is_Concurrent_Interface
(T
: Entity_Id
) return Boolean;
1936 -- First determine whether type T is an interface and then check whether
1937 -- it is of protected, synchronized or task kind.
1939 function Is_Current_Instance
(N
: Node_Id
) return Boolean;
1940 -- Predicate is true if N legally denotes a type name within its own
1941 -- declaration. Prior to Ada 2012 this covered only synchronized type
1942 -- declarations. In Ada 2012 it also covers type and subtype declarations
1943 -- with aspects: Invariant, Predicate, and Default_Initial_Condition.
1945 function Is_Current_Instance_Reference_In_Type_Aspect
1946 (N
: Node_Id
) return Boolean;
1947 -- True if N is a reference to a current instance object that occurs within
1948 -- an aspect_specification for a type or subtype. In this case N will be
1949 -- a formal parameter of a subprogram created for a predicate, invariant,
1950 -- or Default_Initial_Condition aspect.
1952 function Is_Declaration
1954 Body_OK
: Boolean := True;
1955 Concurrent_OK
: Boolean := True;
1956 Formal_OK
: Boolean := True;
1957 Generic_OK
: Boolean := True;
1958 Instantiation_OK
: Boolean := True;
1959 Renaming_OK
: Boolean := True;
1960 Stub_OK
: Boolean := True;
1961 Subprogram_OK
: Boolean := True;
1962 Type_OK
: Boolean := True) return Boolean;
1963 -- Determine whether arbitrary node N denotes a declaration depending
1964 -- on the allowed subsets of declarations. Set the following flags to
1965 -- consider specific subsets of declarations:
1967 -- * Body_OK - body declarations
1969 -- * Concurrent_OK - concurrent type declarations
1971 -- * Formal_OK - formal declarations
1973 -- * Generic_OK - generic declarations, including generic renamings
1975 -- * Instantiation_OK - generic instantiations
1977 -- * Renaming_OK - renaming declarations, including generic renamings
1979 -- * Stub_OK - stub declarations
1981 -- * Subprogram_OK - entry, expression function, and subprogram
1984 -- * Type_OK - type declarations, including concurrent types
1986 function Is_Declared_Within_Variant
(Comp
: Entity_Id
) return Boolean;
1987 -- Returns True iff component Comp is declared within a variant part
1989 function Is_Dependent_Component_Of_Mutable_Object
1990 (Object
: Node_Id
) return Boolean;
1991 -- Returns True if Object is the name of a subcomponent that depends on
1992 -- discriminants of a variable whose nominal subtype is unconstrained and
1993 -- not indefinite, and the variable is not aliased. Otherwise returns
1994 -- False. The nodes passed to this function are assumed to denote objects.
1996 function Is_Dereferenced
(N
: Node_Id
) return Boolean;
1997 -- N is a subexpression node of an access type. This function returns true
1998 -- if N appears as the prefix of a node that does a dereference of the
1999 -- access value (selected/indexed component, explicit dereference or a
2000 -- slice), and false otherwise.
2002 function Is_Descendant_Of
(T1
: Entity_Id
; T2
: Entity_Id
) return Boolean;
2003 -- Returns True if type T1 is a descendant of type T2, and false otherwise.
2004 -- This is the RM definition, a type is a descendant of another type if it
2005 -- is the same type or is derived from a descendant of the other type.
2007 function Is_Descendant_Of_Suspension_Object
2008 (Typ
: Entity_Id
) return Boolean;
2009 -- Determine whether type Typ is a descendant of type Suspension_Object
2010 -- defined in Ada.Synchronous_Task_Control. This version is different from
2011 -- Is_Descendant_Of as the detection of Suspension_Object does not involve
2012 -- an entity and by extension a call to RTSfind.
2014 function Is_Double_Precision_Floating_Point_Type
2015 (E
: Entity_Id
) return Boolean;
2016 -- Return whether E is a double precision floating point type,
2017 -- characterized by:
2018 -- . machine_radix = 2
2019 -- . machine_mantissa = 53
2020 -- . machine_emax = 2**10
2021 -- . machine_emin = 3 - machine_emax
2023 function Is_Effectively_Volatile
2025 Ignore_Protected
: Boolean := False) return Boolean;
2026 -- Determine whether a type or object denoted by entity Id is effectively
2027 -- volatile (SPARK RM 7.1.2). To qualify as such, the entity must be either
2028 -- * Volatile without No_Caching
2029 -- * An array type subject to aspect Volatile_Components
2030 -- * An array type whose component type is effectively volatile
2031 -- * A protected type
2032 -- * Descendant of type Ada.Synchronous_Task_Control.Suspension_Object
2034 -- If Ignore_Protected is True, then a protected object/type is treated
2035 -- like a non-protected record object/type for computing the result of
2038 function Is_Effectively_Volatile_For_Reading
2040 Ignore_Protected
: Boolean := False) return Boolean;
2041 -- Determine whether a type or object denoted by entity Id is effectively
2042 -- volatile for reading (SPARK RM 7.1.2). To qualify as such, the entity
2044 -- * Volatile without No_Caching and have Async_Writers or
2045 -- Effective_Reads set to True
2046 -- * An array type subject to aspect Volatile_Components, unless it has
2047 -- Async_Writers and Effective_Reads set to False
2048 -- * An array type whose component type is effectively volatile for
2050 -- * A protected type
2051 -- * Descendant of type Ada.Synchronous_Task_Control.Suspension_Object
2053 -- If Ignore_Protected is True, then a protected object/type is treated
2054 -- like a non-protected record object/type for computing the result of
2057 function Is_Effectively_Volatile_Object
2058 (N
: Node_Id
) return Boolean;
2059 -- Determine whether an arbitrary node denotes an effectively volatile
2060 -- object (SPARK RM 7.1.2).
2062 function Is_Effectively_Volatile_Object_For_Reading
2063 (N
: Node_Id
) return Boolean;
2064 -- Determine whether an arbitrary node denotes an effectively volatile
2065 -- object for reading (SPARK RM 7.1.2).
2067 function Is_Entity_Of_Quantified_Expression
(Id
: Entity_Id
) return Boolean;
2068 -- Determine whether entity Id is the entity of a quantified expression
2070 function Is_Entry_Body
(Id
: Entity_Id
) return Boolean;
2071 -- Determine whether entity Id is the body entity of an entry [family]
2073 function Is_Entry_Declaration
(Id
: Entity_Id
) return Boolean;
2074 -- Determine whether entity Id is the spec entity of an entry [family]
2076 function Is_Explicitly_Aliased
(N
: Node_Id
) return Boolean;
2077 -- Determine if a given node N is an explicitly aliased formal parameter.
2079 function Is_Expanded_Priority_Attribute
(E
: Entity_Id
) return Boolean;
2080 -- Check whether a function in a call is an expanded priority attribute,
2081 -- which is transformed into an Rtsfind call to Get_Ceiling. This expansion
2082 -- does not take place in a configurable runtime.
2084 function Is_Expression_Function
(Subp
: Entity_Id
) return Boolean;
2085 -- Determine whether subprogram [body] Subp denotes an expression function
2087 -- WARNING: There is a matching C declaration of this subprogram in fe.h
2089 function Is_Expression_Function_Or_Completion
2090 (Subp
: Entity_Id
) return Boolean;
2091 -- Determine whether subprogram [body] Subp denotes an expression function
2092 -- or is completed by an expression function body.
2094 function Is_Extended_Precision_Floating_Point_Type
2095 (E
: Entity_Id
) return Boolean;
2096 -- Return whether E is an extended precision floating point type,
2097 -- characterized by:
2098 -- . machine_radix = 2
2099 -- . machine_mantissa = 64
2100 -- . machine_emax = 2**14
2101 -- . machine_emin = 3 - machine_emax
2103 function Is_EVF_Expression
(N
: Node_Id
) return Boolean;
2104 -- Determine whether node N denotes a reference to a formal parameter of
2105 -- a specific tagged type whose related subprogram is subject to pragma
2106 -- Extensions_Visible with value "False" (SPARK RM 6.1.7). Several other
2107 -- constructs fall under this category:
2108 -- 1) A qualified expression whose operand is EVF
2109 -- 2) A type conversion whose operand is EVF
2110 -- 3) An if expression with at least one EVF dependent_expression
2111 -- 4) A case expression with at least one EVF dependent_expression
2113 function Is_False
(U
: Opt_Ubool
) return Boolean;
2114 pragma Inline
(Is_False
);
2115 -- True if U is Boolean'Pos (False) (i.e. Uint_0)
2117 function Is_True
(U
: Opt_Ubool
) return Boolean;
2118 pragma Inline
(Is_True
);
2119 -- True if U is Boolean'Pos (True) (i.e. Uint_1). Also True if U is
2120 -- No_Uint; we allow No_Uint because Static_Boolean returns that in
2121 -- case of error. It doesn't really matter whether the error case is
2122 -- considered True or False, but we don't want this to blow up in that
2125 function Is_Fixed_Model_Number
(U
: Ureal
; T
: Entity_Id
) return Boolean;
2126 -- Returns True iff the number U is a model number of the fixed-point type
2127 -- T, i.e. if it is an exact multiple of Small.
2129 function Is_Full_Access_Object
(N
: Node_Id
) return Boolean;
2130 -- Determine whether arbitrary node N denotes a reference to a full access
2131 -- object as per Ada 2022 RM C.6(8.2).
2133 function Is_Fully_Initialized_Type
(Typ
: Entity_Id
) return Boolean;
2134 -- Typ is a type entity. This function returns true if this type is fully
2135 -- initialized, meaning that an object of the type is fully initialized.
2136 -- Note that initialization resulting from use of pragma Normalize_Scalars
2137 -- does not count. Note that this is only used for the purpose of issuing
2138 -- warnings for objects that are potentially referenced uninitialized. This
2139 -- means that the result returned is not crucial, but should err on the
2140 -- side of thinking things are fully initialized if it does not know.
2142 function Is_Generic_Declaration_Or_Body
(Decl
: Node_Id
) return Boolean;
2143 -- Determine whether arbitrary declaration Decl denotes a generic package,
2144 -- a generic subprogram or a generic body.
2146 function Is_Independent_Object
(N
: Node_Id
) return Boolean;
2147 -- Determine whether arbitrary node N denotes a reference to an independent
2148 -- object as per RM C.6(8).
2150 function Is_Inherited_Operation
(E
: Entity_Id
) return Boolean;
2151 -- E is a subprogram. Return True is E is an implicit operation inherited
2152 -- by a derived type declaration.
2154 function Is_Inherited_Operation_For_Type
2156 Typ
: Entity_Id
) return Boolean;
2157 -- E is a subprogram. Return True is E is an implicit operation inherited
2158 -- by the derived type declaration for type Typ.
2160 function Is_Inlinable_Expression_Function
(Subp
: Entity_Id
) return Boolean;
2161 -- Return True if Subp is an expression function that fulfills all the
2162 -- following requirements for inlining:
2163 -- 1. pragma/aspect Inline_Always
2166 -- 4. No dispatching primitive
2167 -- 5. Result subtype controlled (or with controlled components)
2168 -- 6. Result subtype not subject to type-invariant checks
2169 -- 7. Result subtype not a class-wide type
2170 -- 8. Return expression naming an object global to the function
2171 -- 9. Nominal subtype of the returned object statically compatible
2172 -- with the result subtype of the expression function.
2174 function Is_Iterator
(Typ
: Entity_Id
) return Boolean;
2175 -- AI05-0139-2: Check whether Typ is one of the predefined interfaces in
2176 -- Ada.Iterator_Interfaces, or it is derived from one.
2178 function Is_Iterator_Over_Array
(N
: Node_Id
) return Boolean;
2179 -- N is an iterator specification. Returns True iff N is an iterator over
2180 -- an array, either inside a loop of the form 'for X of A' or a quantified
2181 -- expression of the form 'for all/some X of A' where A is of array type.
2183 function Is_Library_Level_Entity
(E
: Entity_Id
) return Boolean;
2184 -- A library-level declaration is one that is accessible from Standard,
2185 -- i.e. a library unit or an entity declared in a library package.
2187 function Is_Limited_Class_Wide_Type
(Typ
: Entity_Id
) return Boolean;
2188 -- Determine whether a given type is a limited class-wide type, in which
2189 -- case it needs a Master_Id, because extensions of its designated type
2190 -- may include task components. A class-wide type that comes from a
2191 -- limited view must be treated in the same way.
2193 function Is_Local_Variable_Reference
(Expr
: Node_Id
) return Boolean;
2194 -- Determines whether Expr is a reference to a variable or formal parameter
2195 -- of mode OUT or IN OUT of the current enclosing subprogram.
2197 function Is_Master
(N
: Node_Id
) return Boolean;
2198 -- Determine if the given node N constitutes a finalization master
2200 function Is_Name_Reference
(N
: Node_Id
) return Boolean;
2201 -- Determine whether arbitrary node N is a reference to a name. This is
2202 -- similar to Is_Object_Reference but returns True only if N can be renamed
2203 -- without the need for a temporary, the typical example of an object not
2204 -- in this category being a function call.
2206 function Is_Non_Preelaborable_Construct
(N
: Node_Id
) return Boolean;
2207 -- Determine whether arbitrary construct N violates preelaborability as
2208 -- defined in ARM 10.2.1 5-9/3. This routine takes into account both the
2209 -- syntactic and semantic properties of the construct.
2211 function Is_Nontrivial_DIC_Procedure
(Id
: Entity_Id
) return Boolean;
2212 -- Determine whether entity Id denotes the procedure that verifies the
2213 -- assertion expression of pragma Default_Initial_Condition and if it does,
2214 -- the encapsulated expression is nontrivial.
2216 function Is_Null_Extension
2217 (T
: Entity_Id
; Ignore_Privacy
: Boolean := False) return Boolean;
2218 -- Given a tagged type, returns True if argument is a type extension
2219 -- that introduces no new components (discriminant or nondiscriminant).
2220 -- Ignore_Privacy should be True for use in implementing dynamic semantics.
2221 -- Cannot be called with class-wide types.
2223 function Is_Null_Extension_Of
2224 (Descendant
, Ancestor
: Entity_Id
) return Boolean;
2225 -- Given two tagged types, the first a descendant of the second,
2226 -- returns True if every component of Descendant is inherited
2227 -- (directly or indirectly) from Ancestor. Privacy is ignored.
2228 -- Cannot be called with class-wide types.
2230 function Is_Null_Record_Definition
(Record_Def
: Node_Id
) return Boolean;
2231 -- Returns True for an N_Record_Definition node that has no user-defined
2232 -- components (and no variant part).
2234 function Is_Null_Record_Type
2235 (T
: Entity_Id
; Ignore_Privacy
: Boolean := False) return Boolean;
2236 -- Determine whether T is declared with a null record definition, a
2237 -- null component list, or as a type derived from a null record type
2238 -- (with a null extension if tagged). Returns True for interface types,
2239 -- False for discriminated types.
2241 function Is_Object_Image
(Prefix
: Node_Id
) return Boolean;
2242 -- Returns True if an 'Img, 'Image, 'Wide_Image, or 'Wide_Wide_Image
2243 -- attribute is applied to an object.
2245 function Is_Object_Reference
(N
: Node_Id
) return Boolean;
2246 -- Determines if the tree referenced by N represents an object. Both
2247 -- variable and constant objects return True (compare Is_Variable).
2249 function Is_OK_Variable_For_Out_Formal
(AV
: Node_Id
) return Boolean;
2250 -- Used to test if AV is an acceptable formal for an OUT or IN OUT formal.
2251 -- Note that the Is_Variable function is not quite the right test because
2252 -- this is a case in which conversions whose expression is a variable (in
2253 -- the Is_Variable sense) with an untagged type target are considered view
2254 -- conversions and hence variables.
2256 function Is_OK_Volatile_Context
2259 Check_Actuals
: Boolean) return Boolean;
2260 -- Determine whether node Context denotes a "non-interfering context" (as
2261 -- defined in SPARK RM 7.1.3(10)) where volatile reference Obj_Ref can
2262 -- safely reside. When examining references that might be located within
2263 -- actual parameters of a subprogram call that has not been resolved yet,
2264 -- Check_Actuals should be False; such references will be assumed to be
2265 -- legal. They will need to be checked again after subprogram call has
2268 function Is_Package_Contract_Annotation
(Item
: Node_Id
) return Boolean;
2269 -- Determine whether aspect specification or pragma Item is one of the
2270 -- following package contract annotations:
2272 -- Initial_Condition
2276 function Is_Partially_Initialized_Type
2278 Include_Implicit
: Boolean := True) return Boolean;
2279 -- Typ is a type entity. This function returns true if this type is partly
2280 -- initialized, meaning that an object of the type is at least partly
2281 -- initialized (in particular in the record case, that at least one
2282 -- component has an initialization expression, including via Default_Value
2283 -- and Default_Component_Value aspects). Note that initialization
2284 -- resulting from the use of pragma Normalize_Scalars does not count.
2285 -- Include_Implicit controls whether implicit initialization of access
2286 -- values to null, and of discriminant values, is counted as making the
2287 -- type be partially initialized. For the default setting of True, these
2288 -- implicit cases do count, and discriminated types or types containing
2289 -- access values not explicitly initialized will return True. Otherwise
2290 -- if Include_Implicit is False, these cases do not count as making the
2291 -- type be partially initialized.
2293 function Is_Potentially_Unevaluated
(N
: Node_Id
) return Boolean;
2294 -- Predicate to implement definition given in RM 6.1.1 (20/3)
2296 function Is_Potentially_Persistent_Type
(T
: Entity_Id
) return Boolean;
2297 -- Determines if type T is a potentially persistent type. A potentially
2298 -- persistent type is defined (recursively) as a scalar type, an untagged
2299 -- record whose components are all of a potentially persistent type, or an
2300 -- array with all static constraints whose component type is potentially
2301 -- persistent. A private type is potentially persistent if the full type
2302 -- is potentially persistent.
2304 function Is_Predefined_Dispatching_Operation
(E
: Entity_Id
) return Boolean;
2305 -- Ada 2005 (AI-251): Determines if E is a predefined primitive operation
2307 function Is_Predefined_Interface_Primitive
(E
: Entity_Id
) return Boolean;
2308 -- Ada 2005 (AI-345): Returns True if E is one of the predefined primitives
2309 -- required to implement interfaces.
2311 function Is_Predefined_Internal_Operation
(E
: Entity_Id
) return Boolean;
2312 -- Similar to the previous one, but excludes stream operations, because
2313 -- these may be overridden, and need extra formals, like user-defined
2316 function Is_Preelaborable_Aggregate
(Aggr
: Node_Id
) return Boolean;
2317 -- Determine whether aggregate Aggr violates the restrictions of
2318 -- preelaborable constructs as defined in ARM 10.2.1(5-9).
2320 function Is_Preelaborable_Construct
(N
: Node_Id
) return Boolean;
2321 -- Determine whether arbitrary node N violates the restrictions of
2322 -- preelaborable constructs as defined in ARM 10.2.1(5-9). Routine
2323 -- Is_Non_Preelaborable_Construct takes into account the syntactic
2324 -- and semantic properties of N for a more accurate diagnostic.
2326 function Is_Private_Library_Unit
(Unit
: Entity_Id
) return Boolean;
2327 -- Returns True if and only if the library unit is declared with an
2328 -- explicit designation of private.
2330 function Is_Protected_Self_Reference
(N
: Node_Id
) return Boolean;
2331 -- Return True if node N denotes a protected type name which represents
2332 -- the current instance of a protected object according to RM 9.4(21/2).
2334 function Is_RCI_Pkg_Spec_Or_Body
(Cunit
: Node_Id
) return Boolean;
2335 -- Return True if a compilation unit is the specification or the
2336 -- body of a remote call interface package.
2338 function Is_Remote_Access_To_Class_Wide_Type
(E
: Entity_Id
) return Boolean;
2339 -- Return True if E is a remote access-to-class-wide type
2341 function Is_Remote_Access_To_Subprogram_Type
(E
: Entity_Id
) return Boolean;
2342 -- Return True if E is a remote access to subprogram type
2344 function Is_Remote_Call
(N
: Node_Id
) return Boolean;
2345 -- Return True if N denotes a potentially remote call
2347 function Is_Renamed_Entry
(Proc_Nam
: Entity_Id
) return Boolean;
2348 -- Return True if Proc_Nam is a procedure renaming of an entry
2350 function Is_Reversible_Iterator
(Typ
: Entity_Id
) return Boolean;
2351 -- AI05-0139-2: Check whether Typ is derived from the predefined interface
2352 -- Ada.Iterator_Interfaces.Reversible_Iterator.
2354 function Is_Single_Concurrent_Object
(Id
: Entity_Id
) return Boolean;
2355 -- Determine whether arbitrary entity Id denotes the anonymous object
2356 -- created for a single protected or single task type.
2358 function Is_Single_Concurrent_Type
(Id
: Entity_Id
) return Boolean;
2359 -- Determine whether arbitrary entity Id denotes a single protected or
2360 -- single task type.
2362 function Is_Single_Concurrent_Type_Declaration
(N
: Node_Id
) return Boolean;
2363 -- Determine whether arbitrary node N denotes the declaration of a single
2364 -- protected type or single task type.
2366 function Is_Single_Precision_Floating_Point_Type
2367 (E
: Entity_Id
) return Boolean;
2368 -- Return whether E is a single precision floating point type,
2369 -- characterized by:
2370 -- . machine_radix = 2
2371 -- . machine_mantissa = 24
2372 -- . machine_emax = 2**7
2373 -- . machine_emin = 3 - machine_emax
2375 function Is_Single_Protected_Object
(Id
: Entity_Id
) return Boolean;
2376 -- Determine whether arbitrary entity Id denotes the anonymous object
2377 -- created for a single protected type.
2379 function Is_Single_Task_Object
(Id
: Entity_Id
) return Boolean;
2380 -- Determine whether arbitrary entity Id denotes the anonymous object
2381 -- created for a single task type.
2383 function Is_Special_Aliased_Formal_Access
2385 In_Return_Context
: Boolean := False) return Boolean;
2386 -- Determines whether a dynamic check must be generated for explicitly
2387 -- aliased formals within a function Scop for the expression Exp.
2389 -- In_Return_Context forces Is_Special_Aliased_Formal_Access to assume
2390 -- that Exp is within a return value which is useful for checking
2391 -- expressions within discriminant associations of return objects.
2393 -- More specially, Is_Special_Aliased_Formal_Access checks that Exp is a
2394 -- 'Access attribute reference within a return statement where the ultimate
2395 -- prefix is an aliased formal of Scop and that Scop returns an anonymous
2396 -- access type. See RM 3.10.2 for more details.
2398 function Is_Specific_Tagged_Type
(Typ
: Entity_Id
) return Boolean;
2399 -- Determine whether an arbitrary [private] type is specifically tagged
2401 function Is_Statement
(N
: Node_Id
) return Boolean;
2402 pragma Inline
(Is_Statement
);
2403 -- Check if the node N is a statement node. Note that this includes
2404 -- the case of procedure call statements (unlike the direct use of
2405 -- the N_Statement_Other_Than_Procedure_Call subtype from Sinfo).
2406 -- Note that a label is *not* a statement, and will return False.
2408 function Is_Static_Discriminant_Component
(N
: Node_Id
) return Boolean;
2409 -- Return True if N is guaranteed to a selected component containing a
2410 -- statically known discriminant.
2411 -- Note that this routine takes a conservative view and may return False
2412 -- in some cases where N would match the criteria. In other words this
2413 -- routine should be used to simplify or optimize the expanded code.
2415 function Is_Static_Function
(Subp
: Entity_Id
) return Boolean;
2416 -- Determine whether subprogram Subp denotes a static function,
2417 -- which is a function with the aspect Static with value True.
2419 function Is_Static_Function_Call
(Call
: Node_Id
) return Boolean;
2420 -- Determine whether Call is a static call to a static function,
2421 -- meaning that the name of the call denotes a static function
2422 -- and all of the call's actual parameters are given by static expressions.
2424 function Is_Subcomponent_Of_Full_Access_Object
(N
: Node_Id
) return Boolean;
2425 -- Determine whether arbitrary node N denotes a reference to a subcomponent
2426 -- of a full access object as per RM C.6(7).
2428 function Is_Subprogram_Contract_Annotation
(Item
: Node_Id
) return Boolean;
2429 -- Determine whether aspect specification or pragma Item is one of the
2430 -- following subprogram contract annotations:
2433 -- Extensions_Visible
2444 -- Subprogram_Variant
2447 function Is_Subprogram_Stub_Without_Prior_Declaration
2448 (N
: Node_Id
) return Boolean;
2449 -- Given an N_Subprogram_Body_Stub node N, return True if N is a subprogram
2450 -- stub with no prior subprogram declaration.
2452 function Is_Suitable_Primitive
(Subp_Id
: Entity_Id
) return Boolean;
2453 -- Determine whether arbitrary subprogram Subp_Id may act as a primitive of
2454 -- an arbitrary tagged type.
2456 function Is_Synchronized_Object
(Id
: Entity_Id
) return Boolean;
2457 -- Determine whether entity Id denotes an object and if it does, whether
2458 -- this object is synchronized as specified in SPARK RM 9.1. To qualify as
2459 -- such, the object must be
2460 -- * Of a type that yields a synchronized object
2461 -- * An atomic object with enabled Async_Writers
2462 -- * A constant not of access-to-variable type
2463 -- * A variable subject to pragma Constant_After_Elaboration
2465 function Is_Synchronized_Tagged_Type
(E
: Entity_Id
) return Boolean;
2466 -- Returns True if E is a synchronized tagged type (AARM 3.9.4 (6/2))
2468 function Is_Transfer
(N
: Node_Id
) return Boolean;
2469 -- Returns True if the node N is a statement which is known to cause an
2470 -- unconditional transfer of control at run time, i.e. the following
2471 -- statement definitely will not be executed.
2473 function Is_Unchecked_Conversion_Instance
(Id
: Entity_Id
) return Boolean;
2474 -- Determine whether an arbitrary entity denotes an instance of function
2475 -- Ada.Unchecked_Conversion.
2477 function Is_Universal_Numeric_Type
(T
: Entity_Id
) return Boolean;
2478 pragma Inline
(Is_Universal_Numeric_Type
);
2479 -- True if T is Universal_Integer or Universal_Real
2481 function Is_User_Defined_Equality
(Id
: Entity_Id
) return Boolean;
2482 -- Determine whether an entity denotes a user-defined equality
2484 function Is_User_Defined_Literal
2486 Typ
: Entity_Id
) return Boolean;
2487 pragma Inline
(Is_User_Defined_Literal
);
2488 -- Determine whether N is a user-defined literal for Typ
2490 function Is_Validation_Variable_Reference
(N
: Node_Id
) return Boolean;
2491 -- Determine whether N denotes a reference to a variable which captures the
2492 -- value of an object for validation purposes.
2494 function Is_Variable_Size_Array
(E
: Entity_Id
) return Boolean;
2495 -- Returns true if E has variable size components
2497 function Is_Variable_Size_Record
(E
: Entity_Id
) return Boolean;
2498 -- Returns true if E has variable size components
2500 -- WARNING: There is a matching C declaration of this subprogram in fe.h
2502 function Is_Variable
2504 Use_Original_Node
: Boolean := True) return Boolean;
2505 -- Determines if the tree referenced by N represents a variable, i.e. can
2506 -- appear on the left side of an assignment. There is one situation (formal
2507 -- parameters) in which untagged type conversions are also considered
2508 -- variables, but Is_Variable returns False for such cases, since it has
2509 -- no knowledge of the context. Note that this is the point at which
2510 -- Assignment_OK is checked, and True is returned for any tree thus marked.
2511 -- Use_Original_Node is used to perform the test on Original_Node (N). By
2512 -- default is True since this routine is commonly invoked as part of the
2513 -- semantic analysis and it must not be disturbed by the rewriten nodes.
2515 function Is_View_Conversion
(N
: Node_Id
) return Boolean;
2516 -- Returns True if N is a type_conversion whose operand is the name of an
2517 -- object and both its target type and operand type are tagged, or it
2518 -- appears in a call as an actual parameter of mode out or in out
2521 function Is_Visibly_Controlled
(T
: Entity_Id
) return Boolean;
2522 -- Check whether T is derived from a visibly controlled type. This is true
2523 -- if the root type is declared in Ada.Finalization. If T is derived
2524 -- instead from a private type whose full view is controlled, an explicit
2525 -- Initialize/Adjust/Finalize subprogram does not override the inherited
2528 function Is_Volatile_Full_Access_Object_Ref
(N
: Node_Id
) return Boolean;
2529 -- Determine whether arbitrary node N denotes a reference to an object
2530 -- which is Volatile_Full_Access.
2532 function Is_Volatile_Function
(Func_Id
: Entity_Id
) return Boolean;
2533 -- Determine whether [generic] function Func_Id is subject to enabled
2534 -- pragma Volatile_Function. Protected functions are treated as volatile
2535 -- (SPARK RM 7.1.2).
2537 function Is_Volatile_Object_Ref
(N
: Node_Id
) return Boolean;
2538 -- Determine whether arbitrary node N denotes a reference to a volatile
2539 -- object as per RM C.6(8). Note that the test here is for something that
2540 -- is actually declared as volatile, not for an object that gets treated
2541 -- as volatile (see Einfo.Treat_As_Volatile).
2544 with procedure Handle_Parameter
(Formal
: Entity_Id
; Actual
: Node_Id
);
2545 procedure Iterate_Call_Parameters
(Call
: Node_Id
);
2546 -- Calls Handle_Parameter for each pair of formal and actual parameters of
2547 -- a function, procedure, or entry call.
2549 function Itype_Has_Declaration
(Id
: Entity_Id
) return Boolean;
2550 -- Applies to Itypes. True if the Itype is attached to a declaration for
2551 -- the type through its Parent field, which may or not be present in the
2554 procedure Kill_Current_Values
(Last_Assignment_Only
: Boolean := False);
2555 -- This procedure is called to clear all constant indications from all
2556 -- entities in the current scope and in any parent scopes if the current
2557 -- scope is a block or a package (and that recursion continues to the top
2558 -- scope that is not a block or a package). This is used when the
2559 -- sequential flow-of-control assumption is violated (occurrence of a
2560 -- label, head of a loop, or start of an exception handler). The effect of
2561 -- the call is to clear the Current_Value field (but we do not need to
2562 -- clear the Is_True_Constant flag, since that only gets reset if there
2563 -- really is an assignment somewhere in the entity scope). This procedure
2564 -- also calls Kill_All_Checks, since this is a special case of needing to
2565 -- forget saved values. This procedure also clears the Is_Known_Null and
2566 -- Is_Known_Non_Null and Is_Known_Valid flags in variables, constants or
2567 -- parameters since these are also not known to be trustable any more.
2569 -- The Last_Assignment_Only flag is set True to clear only Last_Assignment
2570 -- fields and leave other fields unchanged. This is used when we encounter
2571 -- an unconditional flow of control change (return, goto, raise). In such
2572 -- cases we don't need to clear the current values, since it may be that
2573 -- the flow of control change occurs in a conditional context, and if it
2574 -- is not taken, then it is just fine to keep the current values. But the
2575 -- Last_Assignment field is different, if we have a sequence assign-to-v,
2576 -- conditional-return, assign-to-v, we do not want to complain that the
2577 -- second assignment clobbers the first.
2579 procedure Kill_Current_Values
2581 Last_Assignment_Only
: Boolean := False);
2582 -- This performs the same processing as described above for the form with
2583 -- no argument, but for the specific entity given. The call has no effect
2584 -- if the entity Ent is not for an object. Last_Assignment_Only has the
2585 -- same meaning as for the call with no Ent.
2587 procedure Kill_Size_Check_Code
(E
: Entity_Id
);
2588 -- Called when an address clause or pragma Import is applied to an entity.
2589 -- If the entity is a variable or a constant, and size check code is
2590 -- present, this size check code is killed, since the object will not be
2591 -- allocated by the program.
2593 function Known_Non_Null
(N
: Node_Id
) return Boolean;
2594 -- Given a node N for a subexpression of an access type, determines if
2595 -- this subexpression yields a value that is known at compile time to
2596 -- be non-null and returns True if so. Returns False otherwise. It is
2597 -- an error to call this function if N is not of an access type.
2599 function Known_Null
(N
: Node_Id
) return Boolean;
2600 -- Given a node N for a subexpression of an access type, determines if this
2601 -- subexpression yields a value that is known at compile time to be null
2602 -- and returns True if so. Returns False otherwise. It is an error to call
2603 -- this function if N is not of an access type.
2605 function Known_To_Be_Assigned
2607 Only_LHS
: Boolean := False) return Boolean;
2608 -- The node N is an entity reference. This function determines whether the
2609 -- reference is for sure an assignment of the entity, returning True if
2610 -- so. Only_LHS will modify this behavior such that actuals for out or
2611 -- in out parameters will not be considered assigned.
2613 function Last_Source_Statement
(HSS
: Node_Id
) return Node_Id
;
2614 -- HSS is a handled statement sequence. This function returns the last
2615 -- statement in Statements (HSS) that has Comes_From_Source set. If no
2616 -- such statement exists, Empty is returned.
2618 procedure Mark_Coextensions
(Context_Nod
: Node_Id
; Root_Nod
: Node_Id
);
2619 -- Given a node which designates the context of analysis and an origin in
2620 -- the tree, traverse from Root_Nod and mark all allocators as either
2621 -- dynamic or static depending on Context_Nod. Any incorrect marking is
2622 -- cleaned up during resolution.
2624 procedure Mark_Elaboration_Attributes
2625 (N_Id
: Node_Or_Entity_Id
;
2626 Checks
: Boolean := False;
2627 Level
: Boolean := False;
2628 Modes
: Boolean := False;
2629 Warnings
: Boolean := False);
2630 -- Preserve relevant elaboration-related properties of the context in
2631 -- arbitrary entity or node N_Id. The flags control the properties as
2634 -- Checks - Save the status of Elaboration_Check
2635 -- Level - Save the declaration level of N_Id (if applicable)
2636 -- Modes - Save the Ghost and SPARK modes in effect (if applicable)
2637 -- Warnings - Save the status of Elab_Warnings
2639 procedure Mark_Save_Invocation_Graph_Of_Body
;
2640 -- Notify the body of the main unit that the invocation constructs and
2641 -- relations expressed within it must be recorded by the ABE mechanism.
2643 function Matching_Static_Array_Bounds
2645 R_Typ
: Node_Id
) return Boolean;
2646 -- L_Typ and R_Typ are two array types. Returns True when they have the
2647 -- same number of dimensions, and the same static bounds for each index
2650 function Might_Raise
(N
: Node_Id
) return Boolean;
2651 -- True if evaluation of N might raise an exception. This is conservative;
2652 -- if we're not sure, we return True. If N is a subprogram body, this is
2653 -- about whether execution of that body can raise.
2655 function Nearest_Class_Condition_Subprogram
2656 (Kind
: Condition_Kind
;
2657 Spec_Id
: Entity_Id
) return Entity_Id
;
2658 -- Return the nearest ancestor containing the merged class-wide conditions
2659 -- that statically apply to Spec_Id; return Empty otherwise.
2661 function Nearest_Enclosing_Instance
(E
: Entity_Id
) return Entity_Id
;
2662 -- Return the entity of the nearest enclosing instance which encapsulates
2663 -- entity E. If no such instance exits, return Empty.
2665 function Needs_Finalization
(Typ
: Entity_Id
) return Boolean;
2666 -- True if Typ requires finalization actions
2668 function Needs_One_Actual
(E
: Entity_Id
) return Boolean;
2669 -- Returns True if a function has defaults for all but its first formal,
2670 -- which is a controlling formal. Used in Ada 2005 mode to solve the
2671 -- syntactic ambiguity that results from an indexing of a function call
2672 -- that returns an array, so that Obj.F (X, Y) may mean F (Ob) (X, Y).
2674 function Needs_Result_Accessibility_Level
2675 (Func_Id
: Entity_Id
) return Boolean;
2676 -- Ada 2012 (AI05-0234): Return True if the function needs an implicit
2677 -- parameter to identify the accessibility level of the function result
2678 -- "determined by the point of call".
2680 function Needs_Simple_Initialization
2682 Consider_IS
: Boolean := True) return Boolean;
2683 -- Certain types need initialization even though there is no specific
2684 -- initialization routine:
2685 -- Access types (which need initializing to null)
2686 -- All scalar types if Normalize_Scalars mode set
2687 -- Descendants of standard string types if Normalize_Scalars mode set
2688 -- Scalar types having a Default_Value attribute
2689 -- Regarding Initialize_Scalars mode, this is ignored if Consider_IS is
2690 -- set to False, but if Consider_IS is set to True, then the cases above
2691 -- mentioning Normalize_Scalars also apply for Initialize_Scalars mode.
2693 function Needs_Variable_Reference_Marker
2695 Calls_OK
: Boolean) return Boolean;
2696 -- Determine whether arbitrary node N denotes a reference to a variable
2697 -- which is suitable for SPARK elaboration checks. Flag Calls_OK should
2698 -- be set when the reference is allowed to appear within calls.
2700 function New_Copy_List_Tree
(List
: List_Id
) return List_Id
;
2701 -- Copy recursively an analyzed list of nodes. Uses New_Copy_Tree defined
2702 -- below. As for New_Copy_Tree, it is illegal to attempt to copy extended
2703 -- nodes (entities) either directly or indirectly using this function.
2705 function New_Copy_Separate_List
(List
: List_Id
) return List_Id
;
2706 -- Copy recursively a list of nodes using New_Copy_Separate_Tree
2708 function New_Copy_Separate_Tree
(Source
: Node_Id
) return Node_Id
;
2709 -- Perform a deep copy of the subtree rooted at Source using New_Copy_Tree
2710 -- replacing entities of local declarations by new entities. This behavior
2711 -- is required by the backend to ensure entities uniqueness when a copy of
2712 -- a subtree is attached to the tree. The new entities keep their original
2713 -- names to facilitate debugging the tree copy.
2715 function New_Copy_Tree
2717 Map
: Elist_Id
:= No_Elist
;
2718 New_Sloc
: Source_Ptr
:= No_Location
;
2719 New_Scope
: Entity_Id
:= Empty
;
2720 Scopes_In_EWA_OK
: Boolean := False) return Node_Id
;
2721 -- Perform a deep copy of the subtree rooted at Source. Entities, itypes,
2722 -- and nodes are handled separately as follows:
2724 -- * A node is replicated by first creating a shallow copy, then copying
2725 -- its syntactic fields, where all Parent pointers of the fields are
2726 -- updated to refer to the copy. In addition, the following semantic
2727 -- fields are recreated after the replication takes place.
2729 -- First_Named_Actual
2730 -- First_Real_Statement
2731 -- Next_Named_Actual
2733 -- If applicable, the Etype field (if any) is updated to refer to a
2734 -- local itype or type (see below).
2736 -- * An entity defined within an N_Expression_With_Actions node in the
2737 -- subtree is given a new entity, and all references to the original
2738 -- entity are updated to refer to the new entity. In addition, the
2739 -- following semantic fields are replicated and/or updated to refer
2740 -- to a local entity or itype.
2742 -- Discriminant_Constraint
2746 -- Packed_Array_Impl_Type
2750 -- Note that currently no other expression can define entities.
2752 -- * An itype whose Associated_Node_For_Itype node is in the subtree
2753 -- is given a new entity, and all references to the original itype
2754 -- are updated to refer to the new itype. In addition, the following
2755 -- semantic fields are replicated and/or updated to refer to a local
2758 -- Discriminant_Constraint
2762 -- Packed_Array_Impl_Type
2766 -- The Associated_Node_For_Itype is updated to refer to a replicated
2769 -- The routine can replicate both analyzed and unanalyzed trees. Copying an
2770 -- Empty or Error node yields the same node.
2772 -- Parameter Map may be used to specify a set of mappings between entities.
2773 -- These mappings are then taken into account when replicating entities.
2774 -- The format of Map must be as follows:
2777 -- new entity to replace references to entity 1
2779 -- new entity to replace references to entity 2
2782 -- Map and its contents are left unchanged.
2784 -- Parameter New_Sloc may be used to specify a new source location for all
2785 -- replicated entities, itypes, and nodes. The Comes_From_Source indicator
2786 -- is defaulted if a new source location is provided.
2788 -- Parameter New_Scope may be used to specify a new scope for all copied
2789 -- entities and itypes.
2791 -- Parameter Scopes_In_EWA_OK may be used to force the replication of both
2792 -- scoping entities and non-scoping entities found within expression with
2795 function New_External_Entity
2796 (Kind
: Entity_Kind
;
2797 Scope_Id
: Entity_Id
;
2798 Sloc_Value
: Source_Ptr
;
2799 Related_Id
: Entity_Id
;
2801 Suffix_Index
: Int
:= 0;
2802 Prefix
: Character := ' ') return Entity_Id
;
2803 -- This function creates an N_Defining_Identifier node for an internal
2804 -- created entity, such as an implicit type or subtype, or a record
2805 -- initialization procedure. The entity name is constructed with a call
2806 -- to New_External_Name (Related_Id, Suffix, Suffix_Index, Prefix), so
2807 -- that the generated name may be referenced as a public entry, and the
2808 -- Is_Public flag is set if needed (using Set_Public_Status). If the
2809 -- entity is for a type or subtype, the size/align fields are initialized
2810 -- to unknown (Uint_0).
2812 function New_Internal_Entity
2813 (Kind
: Entity_Kind
;
2814 Scope_Id
: Entity_Id
;
2815 Sloc_Value
: Source_Ptr
;
2816 Id_Char
: Character) return Entity_Id
;
2817 -- This function is similar to New_External_Entity, except that the
2818 -- name is constructed by New_Internal_Name (Id_Char). This is used
2819 -- when the resulting entity does not have to be referenced as a
2820 -- public entity (and in this case Is_Public is not set).
2822 function Next_Actual
(Actual_Id
: Node_Id
) return Node_Id
;
2823 -- Find next actual parameter in declaration order. As described for
2824 -- First_Actual, this is the next actual in the declaration order, not
2825 -- the call order, so this does not correspond to simply taking the
2826 -- next entry of the Parameter_Associations list. The argument is an
2827 -- actual previously returned by a call to First_Actual or Next_Actual.
2828 -- Note that the result produced is always an expression, not a parameter
2829 -- association node, even if named notation was used.
2831 -- WARNING: There is a matching C declaration of this subprogram in fe.h
2833 procedure Next_Actual
(Actual_Id
: in out Node_Id
);
2834 pragma Inline
(Next_Actual
);
2835 -- Next_Actual (N) is equivalent to N := Next_Actual (N). Note that we
2836 -- inline this procedural form, but not the functional form above.
2838 function Next_Global
(Node
: Node_Id
) return Node_Id
;
2839 -- Node is a global item from a list, obtained through calling First_Global
2840 -- and possibly Next_Global a number of times. Returns the next global item
2841 -- with the same mode.
2843 procedure Next_Global
(Node
: in out Node_Id
);
2844 pragma Inline
(Next_Global
);
2845 -- Next_Global (N) is equivalent to N := Next_Global (N). Note that we
2846 -- inline this procedural form, but not the functional form above.
2848 function No_Caching_Enabled
(Id
: Entity_Id
) return Boolean;
2849 -- Given the entity of a variable, determine whether Id is subject to
2850 -- volatility property No_Caching and if it is, the related expression
2851 -- evaluates to True.
2853 function No_Heap_Finalization
(Typ
: Entity_Id
) return Boolean;
2854 -- Determine whether type Typ is subject to pragma No_Heap_Finalization
2856 procedure Normalize_Actuals
2860 Success
: out Boolean);
2861 -- Reorders lists of actuals according to names of formals, value returned
2862 -- in Success indicates success of reordering. For more details, see body.
2863 -- Errors are reported only if Report is set to True.
2865 procedure Note_Possible_Modification
(N
: Node_Id
; Sure
: Boolean);
2866 -- This routine is called if the sub-expression N maybe the target of
2867 -- an assignment (e.g. it is the left side of an assignment, used as
2868 -- an out parameters, or used as prefixes of access attributes). It
2869 -- sets May_Be_Modified in the associated entity if there is one,
2870 -- taking into account the rule that in the case of renamed objects,
2871 -- it is the flag in the renamed object that must be set.
2873 -- The parameter Sure is set True if the modification is sure to occur
2874 -- (e.g. target of assignment, or out parameter), and to False if the
2875 -- modification is only potential (e.g. address of entity taken).
2877 function Null_To_Null_Address_Convert_OK
2879 Typ
: Entity_Id
:= Empty
) return Boolean;
2880 -- Return True if we are compiling in relaxed RM semantics mode and:
2881 -- 1) N is a N_Null node and Typ is a descendant of System.Address, or
2882 -- 2) N is a comparison operator, one of the operands is null, and the
2883 -- type of the other operand is a descendant of System.Address.
2885 function Number_Of_Elements_In_Array
(T
: Entity_Id
) return Int
;
2886 -- Returns the number of elements in the array T if the index bounds of T
2887 -- is known at compile time. If the bounds are not known at compile time,
2888 -- the function returns the value zero.
2890 function Original_Aspect_Pragma_Name
(N
: Node_Id
) return Name_Id
;
2891 -- Retrieve the name of aspect or pragma N, taking into account a possible
2892 -- rewrite and whether the pragma is generated from an aspect as the names
2893 -- may be different. The routine also deals with 'Class in which case it
2894 -- returns the following values:
2896 -- Invariant -> Name_uInvariant
2897 -- Post'Class -> Name_uPost
2898 -- Pre'Class -> Name_uPre
2899 -- Type_Invariant -> Name_uType_Invariant
2900 -- Type_Invariant'Class -> Name_uType_Invariant
2902 function Original_Corresponding_Operation
(S
: Entity_Id
) return Entity_Id
;
2903 -- [Ada 2012: AI05-0125-1]: If S is an inherited dispatching primitive S2,
2904 -- or overrides an inherited dispatching primitive S2, the original
2905 -- corresponding operation of S is the original corresponding operation of
2906 -- S2. Otherwise, it is S itself.
2908 function Original_View_In_Visible_Part
(Typ
: Entity_Id
) return Boolean;
2909 -- Returns True if the type Typ has a private view or if the public view
2910 -- appears in the visible part of a package spec.
2912 procedure Output_Entity
(Id
: Entity_Id
);
2913 -- Print entity Id to standard output. The name of the entity appears in
2914 -- fully qualified form.
2916 -- WARNING: this routine should be used in debugging scenarios such as
2917 -- tracking down undefined symbols as it is fairly low level.
2919 procedure Output_Name
(Nam
: Name_Id
; Scop
: Entity_Id
:= Current_Scope
);
2920 -- Print name Nam to standard output. The name appears in fully qualified
2921 -- form assuming it appears in scope Scop. Note that this may not reflect
2922 -- the final qualification as the entity which carries the name may be
2923 -- relocated to a different scope.
2925 -- WARNING: this routine should be used in debugging scenarios such as
2926 -- tracking down undefined symbols as it is fairly low level.
2928 function Param_Entity
(N
: Node_Id
) return Entity_Id
;
2929 -- Given an expression N, determines if the expression is a reference
2930 -- to a formal (of a subprogram or entry), and if so returns the Id
2931 -- of the corresponding formal entity, otherwise returns Empty. Also
2932 -- handles the case of references to renamings of formals.
2934 function Policy_In_Effect
(Policy
: Name_Id
) return Name_Id
;
2935 -- Given a policy, return the policy identifier associated with it. If no
2936 -- such policy is in effect, the value returned is No_Name.
2938 function Predicate_Enabled
(Typ
: Entity_Id
) return Boolean;
2939 -- Return True if a predicate check should be emitted for the given type
2940 -- Typ, taking into account Predicates_Ignored and
2941 -- Predicate_Checks_Suppressed.
2943 function Predicate_Failure_Expression
2944 (Typ
: Entity_Id
; Inherited_OK
: Boolean) return Node_Id
;
2945 -- If the given type or subtype is subject to a Predicate_Failure
2946 -- aspect specification, then returns the specified expression.
2947 -- Otherwise, if Inherited_OK is False then returns Empty.
2948 -- Otherwise, if Typ denotes a subtype or a derived type then
2949 -- returns the result of recursing on the ancestor subtype.
2950 -- Otherwise, returns Empty.
2952 function Predicate_Function_Needs_Membership_Parameter
(Typ
: Entity_Id
)
2954 (Present
(Predicate_Failure_Expression
(Typ
, Inherited_OK
=> True)));
2955 -- The predicate function for some, but not all, subtypes needs to
2956 -- know whether the predicate is being evaluated as part of a membership
2957 -- test. The predicate function for such a subtype takes an additional
2958 -- boolean to convey this information. This function returns True if this
2959 -- additional parameter is needed. More specifically, this function
2960 -- returns true if the Predicate_Failure aspect is specified for the
2961 -- given subtype or for any of its "ancestor" subtypes.
2963 function Predicate_Tests_On_Arguments
(Subp
: Entity_Id
) return Boolean;
2964 -- Subp is the entity for a subprogram call. This function returns True if
2965 -- predicate tests are required for the arguments in this call (this is the
2966 -- normal case). It returns False for special cases where these predicate
2967 -- tests should be skipped (see body for details).
2969 function Primitive_Names_Match
(E1
, E2
: Entity_Id
) return Boolean;
2970 -- Returns True if the names of both entities correspond with matching
2971 -- primitives. This routine includes support for the case in which one
2972 -- or both entities correspond with entities built by Derive_Subprogram
2973 -- with a special name to avoid being overridden (i.e. return true in case
2974 -- of entities with names "nameP" and "name" or vice versa).
2976 function Private_Component
(Type_Id
: Entity_Id
) return Entity_Id
;
2977 -- Returns some private component (if any) of the given Type_Id.
2978 -- Used to enforce the rules on visibility of operations on composite
2979 -- types, that depend on the full view of the component type. For a
2980 -- record type there may be several such components, we just return
2983 procedure Process_End_Label
2987 -- N is a node whose End_Label is to be processed, generating all
2988 -- appropriate cross-reference entries, and performing style checks
2989 -- for any identifier references in the end label. Typ is either
2990 -- 'e' or 't indicating the type of the cross-reference entity
2991 -- (e for spec, t for body, see Lib.Xref spec for details). The
2992 -- parameter Ent gives the entity to which the End_Label refers,
2993 -- and to which cross-references are to be generated.
2995 procedure Propagate_Concurrent_Flags
2997 Comp_Typ
: Entity_Id
);
2998 -- Set Has_Task, Has_Protected, and Has_Timing_Event on Typ when the flags
2999 -- are set on Comp_Typ. This follows the definition of these flags, which
3000 -- are set (recursively) on any composite type that has a component marked
3001 -- by one of these flags. This procedure can only set flags for Typ, and
3002 -- never clear them. Comp_Typ is the type of a component or a parent.
3004 procedure Propagate_DIC_Attributes
3006 From_Typ
: Entity_Id
);
3007 -- Inherit all Default_Initial_Condition-related attributes from type
3008 -- From_Typ. Typ is the destination type.
3010 procedure Propagate_Invariant_Attributes
3012 From_Typ
: Entity_Id
);
3013 -- Inherit all invariant-related attributes from type From_Typ. Typ is the
3014 -- destination type.
3016 procedure Propagate_Predicate_Attributes
3018 From_Typ
: Entity_Id
);
3019 -- Inherit predicate functions and Has_Predicates flag from type From_Typ.
3020 -- Typ is the destination type.
3022 procedure Record_Possible_Part_Of_Reference
3023 (Var_Id
: Entity_Id
;
3025 -- Save reference Ref to variable Var_Id when the variable is subject to
3026 -- pragma Part_Of. If the variable is known to be a constituent of a single
3027 -- protected/task type, the legality of the reference is verified and the
3028 -- save does not take place.
3030 function Referenced
(Id
: Entity_Id
; Expr
: Node_Id
) return Boolean;
3031 -- Determine whether entity Id is referenced within expression Expr
3033 function References_Generic_Formal_Type
(N
: Node_Id
) return Boolean;
3034 -- Returns True if the expression Expr contains any references to a generic
3035 -- type. This can only happen within a generic template.
3037 procedure Remove_Entity_And_Homonym
(Id
: Entity_Id
);
3038 -- Remove arbitrary entity Id from both the homonym and scope chains. Use
3039 -- Remove_Overloaded_Entity for overloadable entities. Note: the removal
3040 -- performed by this routine does not affect the visibility of existing
3043 procedure Remove_Homonym
(Id
: Entity_Id
);
3044 -- Removes entity Id from the homonym chain
3046 procedure Remove_Overloaded_Entity
(Id
: Entity_Id
);
3047 -- Remove arbitrary entity Id from the homonym chain, the scope chain and
3048 -- the primitive operations list of the associated controlling type. Use
3049 -- Remove_Entity for non-overloadable entities. Note: the removal performed
3050 -- by this routine does not affect the visibility of existing homonyms.
3052 function Remove_Suffix
(E
: Entity_Id
; Suffix
: Character) return Name_Id
;
3053 -- Returns the name of E without Suffix
3055 procedure Replace_Null_By_Null_Address
(N
: Node_Id
);
3056 -- N is N_Null or a binary comparison operator, we are compiling in relaxed
3057 -- RM semantics mode, and one of the operands is null. Replace null with
3058 -- System.Null_Address.
3060 function Rep_To_Pos_Flag
(E
: Entity_Id
; Loc
: Source_Ptr
) return Node_Id
;
3061 -- This is used to construct the second argument in a call to Rep_To_Pos
3062 -- which is Standard_True if range checks are enabled (E is an entity to
3063 -- which the Range_Checks_Suppressed test is applied), and Standard_False
3064 -- if range checks are suppressed. Loc is the location for the node that
3065 -- is returned (which is a New_Occurrence of the appropriate entity).
3067 -- Note: one might think that it would be fine to always use True and
3068 -- to ignore the suppress in this case, but it is generally better to
3069 -- believe a request to suppress exceptions if possible, and further
3070 -- more there is at least one case in the generated code (the code for
3071 -- array assignment in a loop) that depends on this suppression.
3073 procedure Require_Entity
(N
: Node_Id
);
3074 -- N is a node which should have an entity value if it is an entity name.
3075 -- If not, then check if there were previous errors. If so, just fill
3076 -- in with Any_Id and ignore. Otherwise signal a program error exception.
3077 -- This is used as a defense mechanism against ill-formed trees caused by
3078 -- previous errors (particularly in -gnatq mode).
3080 function Requires_Transient_Scope
(Typ
: Entity_Id
) return Boolean;
3081 pragma Inline
(Requires_Transient_Scope
);
3082 -- Return true if temporaries of Typ need to be wrapped in a transient
3083 -- scope, either because they are allocated on the secondary stack or
3084 -- finalization actions must be generated before the next instruction.
3085 -- Examples of types requiring such wrapping are variable-sized types,
3086 -- including unconstrained arrays, and controlled types.
3088 procedure Reset_Analyzed_Flags
(N
: Node_Id
);
3089 -- Reset the Analyzed flags in all nodes of the tree whose root is N
3091 procedure Restore_SPARK_Mode
(Mode
: SPARK_Mode_Type
; Prag
: Node_Id
);
3092 -- Set the current SPARK_Mode to Mode and SPARK_Mode_Pragma to Prag. This
3093 -- routine must be used in tandem with Set_SPARK_Mode.
3095 function Returns_On_Secondary_Stack
(Id
: Entity_Id
) return Boolean;
3096 -- Return true if functions whose result type is Id must return on the
3097 -- secondary stack, i.e. allocate the return object on this stack.
3099 -- WARNING: There is a matching C declaration of this subprogram in fe.h
3101 function Returns_Unconstrained_Type
(Subp
: Entity_Id
) return Boolean;
3102 -- Return true if Subp is a function that returns an unconstrained type
3104 function Root_Type_Of_Full_View
(T
: Entity_Id
) return Entity_Id
;
3105 -- Similar to attribute Root_Type, but this version always follows the
3106 -- Full_View of a private type (if available) while searching for the
3107 -- ultimate derivation ancestor.
3109 function Safe_To_Capture_Value
3112 Cond
: Boolean := False) return Boolean;
3113 -- The caller is interested in capturing a value (either the current
3114 -- value, an indication that the value is [non-]null or an indication that
3115 -- the value is valid) for the given entity Ent. This value can only be
3116 -- captured if sequential execution semantics can be properly guaranteed so
3117 -- that a subsequent reference will indeed be sure that this current value
3118 -- indication is correct. The node N is the construct that resulted in the
3119 -- possible capture of the value (this is used to check if we are in a
3122 -- Cond is used to skip the test for being inside a conditional. It is used
3123 -- in the case of capturing values from if/while tests, which already do a
3124 -- proper job of handling scoping issues without this help.
3126 -- The only entities whose values can be captured are OUT and IN OUT formal
3127 -- parameters, and variables unless Cond is True, in which case we also
3128 -- allow IN formals, loop parameters and constants, where we cannot ever
3129 -- capture actual value information, but we can capture conditional tests.
3131 function Same_Name
(N1
, N2
: Node_Id
) return Boolean;
3132 -- Determine if two (possibly expanded) names are the same name. This is
3133 -- a purely syntactic test, and N1 and N2 need not be analyzed.
3135 function Same_Object
(Node1
, Node2
: Node_Id
) return Boolean;
3136 -- Determine if Node1 and Node2 are known to designate the same object.
3137 -- This is a semantic test and both nodes must be fully analyzed. A result
3138 -- of True is decisively correct. A result of False does not necessarily
3139 -- mean that different objects are designated, just that this could not
3140 -- be reliably determined at compile time.
3142 function Same_Or_Aliased_Subprograms
3144 E
: Entity_Id
) return Boolean;
3145 -- Returns True if the subprogram entity S is the same as E or else S is an
3148 function Same_Type
(T1
, T2
: Entity_Id
) return Boolean;
3149 -- Determines if T1 and T2 represent exactly the same type. Two types
3150 -- are the same if they are identical, or if one is an unconstrained
3151 -- subtype of the other, or they are both common subtypes of the same
3152 -- type with identical constraints. The result returned is conservative.
3153 -- It is True if the types are known to be the same, but a result of
3154 -- False is indecisive (e.g. the compiler may not be able to tell that
3155 -- two constraints are identical).
3157 function Same_Value
(Node1
, Node2
: Node_Id
) return Boolean;
3158 -- Determines if Node1 and Node2 are known to be the same value, which is
3159 -- true if they are both compile time known values and have the same value,
3160 -- or if they are the same object (in the sense of function Same_Object).
3161 -- A result of False does not necessarily mean they have different values,
3162 -- just that it is not possible to determine they have the same value.
3164 function Scalar_Part_Present
(Typ
: Entity_Id
) return Boolean;
3165 -- Determine whether arbitrary type Typ is a scalar type, or contains at
3166 -- least one scalar subcomponent.
3168 function Scope_Within
3170 Outer
: Entity_Id
) return Boolean;
3171 -- Determine whether scope Inner appears within scope Outer. Note that
3172 -- scopes are partially ordered, so Scope_Within (A, B) and Scope_Within
3173 -- (B, A) may both return False.
3175 function Scope_Within_Or_Same
3177 Outer
: Entity_Id
) return Boolean;
3178 -- Determine whether scope Inner appears within scope Outer or both denote
3179 -- the same scope. Note that scopes are partially ordered, so Scope_Within
3180 -- (A, B) and Scope_Within (B, A) may both return False.
3182 procedure Set_Current_Entity
(E
: Entity_Id
);
3183 pragma Inline
(Set_Current_Entity
);
3184 -- Establish the entity E as the currently visible definition of its
3185 -- associated name (i.e. the Node_Id associated with its name).
3187 procedure Set_Debug_Info_Defining_Id
(N
: Node_Id
);
3188 -- Call Set_Debug_Info_Needed on Defining_Identifier (N) if it comes
3191 procedure Set_Debug_Info_Needed
(T
: Entity_Id
);
3192 -- Sets the Debug_Info_Needed flag on entity T , and also on any entities
3193 -- that are needed by T (for an object, the type of the object is needed,
3194 -- and for a type, various subsidiary types are needed -- see body for
3195 -- details). Never has any effect on T if the Debug_Info_Off flag is set.
3196 -- This routine should always be used instead of Set_Needs_Debug_Info to
3197 -- ensure that subsidiary entities are properly handled.
3199 procedure Set_Entity_With_Checks
(N
: Node_Id
; Val
: Entity_Id
);
3200 -- This procedure has the same calling sequence as Set_Entity, but it
3201 -- performs additional checks as follows:
3203 -- If Style_Check is set, then it calls a style checking routine that
3204 -- can check identifier spelling style.
3206 -- If restriction No_Abort_Statements is set, then it checks that the
3207 -- entity is not Ada.Task_Identification.Abort_Task.
3209 -- If restriction No_Dynamic_Attachment is set, then it checks that the
3210 -- entity is not one of the restricted names for this restriction.
3212 -- If restriction No_Long_Long_Integers is set, then it checks that the
3213 -- entity is not Standard.Long_Long_Integer.
3215 -- If restriction No_Implementation_Identifiers is set, then it checks
3216 -- that the entity is not implementation defined.
3218 procedure Set_Invalid_Scalar_Value
3219 (Scal_Typ
: Float_Scalar_Id
;
3221 -- Associate invalid value Value with scalar type Scal_Typ as specified by
3222 -- pragma Initialize_Scalars.
3224 procedure Set_Invalid_Scalar_Value
3225 (Scal_Typ
: Integer_Scalar_Id
;
3227 -- Associate invalid value Value with scalar type Scal_Typ as specified by
3228 -- pragma Initialize_Scalars.
3230 procedure Set_Name_Entity_Id
(Id
: Name_Id
; Val
: Entity_Id
);
3231 pragma Inline
(Set_Name_Entity_Id
);
3232 -- Sets the Entity_Id value associated with the given name, which is the
3233 -- Id of the innermost visible entity with the given name. See the body
3234 -- of package Sem_Ch8 for further details on the handling of visibility.
3236 procedure Set_Next_Actual
(Ass1_Id
: Node_Id
; Ass2_Id
: Node_Id
);
3237 -- The arguments may be parameter associations, whose descendants
3238 -- are the optional formal name and the actual parameter. Positional
3239 -- parameters are already members of a list, and do not need to be
3240 -- chained separately. See also First_Actual and Next_Actual.
3242 procedure Set_Optimize_Alignment_Flags
(E
: Entity_Id
);
3243 pragma Inline
(Set_Optimize_Alignment_Flags
);
3244 -- Sets Optimize_Alignment_Space/Time flags in E from current settings
3246 procedure Set_Public_Status
(Id
: Entity_Id
);
3247 -- If an entity (visible or otherwise) is defined in a library
3248 -- package, or a package that is itself public, then this subprogram
3249 -- labels the entity public as well.
3251 procedure Set_Referenced_Modified
(N
: Node_Id
; Out_Param
: Boolean);
3252 -- N is the node for either a left hand side (Out_Param set to False),
3253 -- or an Out or In_Out parameter (Out_Param set to True). If there is
3254 -- an assignable entity being referenced, then the appropriate flag
3255 -- (Referenced_As_LHS if Out_Param is False, Referenced_As_Out_Parameter
3256 -- if Out_Param is True) is set True, and the other flag set False.
3258 procedure Set_Rep_Info
(T1
: Entity_Id
; T2
: Entity_Id
);
3259 pragma Inline
(Set_Rep_Info
);
3260 -- Copies the Is_Atomic, Is_Independent and Is_Volatile_Full_Access flags
3261 -- from sub(type) entity T2 to (sub)type entity T1, as well as Is_Volatile
3262 -- if T1 is a base type.
3264 procedure Set_Scope_Is_Transient
(V
: Boolean := True);
3265 -- Set the flag Is_Transient of the current scope
3267 procedure Set_Size_Info
(T1
, T2
: Entity_Id
);
3268 pragma Inline
(Set_Size_Info
);
3269 -- Copies the Esize field and Has_Biased_Representation flag from sub(type)
3270 -- entity T2 to (sub)type entity T1. Also copies the Is_Unsigned_Type flag
3271 -- in the fixed-point and discrete cases, and also copies the alignment
3272 -- value from T2 to T1. It does NOT copy the RM_Size field, which must be
3273 -- separately set if this is required to be copied also.
3275 procedure Set_SPARK_Mode
(Context
: Entity_Id
);
3276 -- Establish the SPARK_Mode and SPARK_Mode_Pragma (if any) of a package or
3277 -- a subprogram denoted by Context. This routine must be used in tandem
3278 -- with Restore_SPARK_Mode.
3280 function Scope_Is_Transient
return Boolean;
3281 -- True if the current scope is transient
3283 function Should_Ignore_Pragma_Par
(Prag_Name
: Name_Id
) return Boolean;
3284 function Should_Ignore_Pragma_Sem
(N
: Node_Id
) return Boolean;
3285 -- True if we should ignore pragmas with the specified name. In particular,
3286 -- this returns True if pragma Ignore_Pragma applies, and we are not in a
3287 -- predefined unit. The _Par version should be called only from the parser;
3288 -- the _Sem version should be called only during semantic analysis.
3290 function Static_Boolean
(N
: Node_Id
) return Opt_Ubool
;
3291 -- This function analyzes the given expression node and then resolves it
3292 -- as Standard.Boolean. If the result is static, then Uint_1 or Uint_0 is
3293 -- returned corresponding to the value, otherwise an error message is
3294 -- output and No_Uint is returned.
3296 function Static_Integer
(N
: Node_Id
) return Uint
;
3297 -- This function analyzes the given expression node and then resolves it
3298 -- as any integer type. If the result is static, then the value of the
3299 -- universal expression is returned, otherwise an error message is output
3300 -- and a value of No_Uint is returned.
3302 function Statically_Denotes_Entity
(N
: Node_Id
) return Boolean;
3303 -- Return True iff N is a name that "statically denotes" an entity.
3305 function Statically_Denotes_Object
(N
: Node_Id
) return Boolean;
3306 -- Return True iff N is a name that "statically denotes" an object.
3308 function Statically_Different
(E1
, E2
: Node_Id
) return Boolean;
3309 -- Return True if it can be statically determined that the Expressions
3310 -- E1 and E2 refer to different objects
3312 function Statically_Names_Object
(N
: Node_Id
) return Boolean;
3313 -- Return True iff N is a name that "statically names" an object.
3315 function String_From_Numeric_Literal
(N
: Node_Id
) return String_Id
;
3316 -- Return the string that corresponds to the numeric literal N as it
3317 -- appears in the source.
3319 function Subject_To_Loop_Entry_Attributes
(N
: Node_Id
) return Boolean;
3320 -- Determine whether node N is a loop statement subject to at least one
3321 -- 'Loop_Entry attribute.
3323 function Subprogram_Access_Level
(Subp
: Entity_Id
) return Uint
;
3324 -- Return the accessibility level of the view denoted by Subp
3326 function Support_Atomic_Primitives
(Typ
: Entity_Id
) return Boolean;
3327 -- Return True if Typ supports the GCC built-in atomic operations (i.e. if
3328 -- Typ is properly sized and aligned).
3330 procedure Trace_Scope
(N
: Node_Id
; E
: Entity_Id
; Msg
: String);
3331 -- Print debugging information on entry to each unit being analyzed
3333 procedure Transfer_Entities
(From
: Entity_Id
; To
: Entity_Id
);
3334 -- Move a list of entities from one scope to another, and recompute
3335 -- Is_Public based upon the new scope.
3338 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
3339 Process_Itypes
: Boolean := False;
3340 function Traverse_More_Func
(Node
: Node_Id
) return Traverse_Final_Result
;
3341 -- This is a version of Atree.Traverse_Func that not only traverses
3342 -- syntactic children of nodes, but also semantic children which are
3343 -- logically children of the node. This concerns currently lists of
3344 -- action nodes and ranges under Itypes, both inserted by the compiler.
3345 -- Itypes are only traversed when Process_Itypes is True.
3348 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
3349 Process_Itypes
: Boolean := False;
3350 procedure Traverse_More_Proc
(Node
: Node_Id
);
3351 pragma Inline
(Traverse_More_Proc
);
3352 -- This is the same as Traverse_More_Func except that no result is
3353 -- returned, i.e. Traverse_More_Func is called and the result is simply
3356 function Type_Access_Level
3358 Allow_Alt_Model
: Boolean := True;
3359 Assoc_Ent
: Entity_Id
:= Empty
) return Uint
;
3360 -- Return the accessibility level of Typ
3362 -- The Allow_Alt_Model parameter allows the alternative level calculation
3363 -- under the restriction No_Dynamic_Accessibility_Checks to be performed.
3365 -- Assoc_Ent allows for the optional specification of the entity associated
3366 -- with Typ. This gets utilized mostly for anonymous access type
3367 -- processing, where context matters in interpreting Typ's level.
3369 function Type_Without_Stream_Operation
3371 Op
: TSS_Name_Type
:= TSS_Null
) return Entity_Id
;
3372 -- AI05-0161: In Ada 2012, if the restriction No_Default_Stream_Attributes
3373 -- is active then we cannot generate stream subprograms for composite types
3374 -- with elementary subcomponents that lack user-defined stream subprograms.
3375 -- This predicate determines whether a type has such an elementary
3376 -- subcomponent. If Op is TSS_Null, a type that lacks either Read or Write
3377 -- prevents the construction of a composite stream operation. If Op is
3378 -- specified we check only for the given stream operation.
3380 function Ultimate_Overlaid_Entity
(E
: Entity_Id
) return Entity_Id
;
3381 -- If entity E is overlaying some other entity via an Address clause (which
3382 -- possibly overlays yet another entity via its own Address clause), then
3383 -- return the ultimate overlaid entity. If entity E is not overlaying any
3384 -- other entity (or the overlaid entity cannot be determined statically),
3385 -- then return Empty.
3387 -- Subsidiary to the analysis of object overlays in SPARK.
3389 function Ultimate_Prefix
(N
: Node_Id
) return Node_Id
;
3390 -- Obtain the "outermost" prefix of arbitrary node N. Return N if no such
3393 function Unique_Defining_Entity
(N
: Node_Id
) return Entity_Id
;
3394 -- Return the entity that represents declaration N, so that different
3395 -- views of the same entity have the same unique defining entity:
3396 -- * private view and full view of a deferred constant
3398 -- * entry spec and entry body
3400 -- * formal parameter on spec and body
3401 -- --> formal parameter on spec
3402 -- * package spec, body, and body stub
3404 -- * protected type, protected body, and protected body stub
3405 -- --> protected type (full view if private)
3406 -- * subprogram spec, body, and body stub
3407 -- --> subprogram spec
3408 -- * task type, task body, and task body stub
3409 -- --> task type (full view if private)
3410 -- * private or incomplete view and full view of a type
3412 -- In other cases, return the defining entity for N.
3414 function Unique_Entity
(E
: Entity_Id
) return Entity_Id
;
3415 -- Return the unique entity for entity E, which would be returned by
3416 -- Unique_Defining_Entity if applied to the enclosing declaration of E.
3418 function Unique_Name
(E
: Entity_Id
) return String;
3419 -- Return a unique name for entity E, which could be used to identify E
3420 -- across compilation units.
3422 Child_Prefix
: constant String := "ada___";
3423 -- Prefix for child packages when building a unique name for an entity. It
3424 -- is included here to share between Unique_Name and gnatprove.
3426 function Unit_Is_Visible
(U
: Entity_Id
) return Boolean;
3427 -- Determine whether a compilation unit is visible in the current context,
3428 -- because there is a with_clause that makes the unit available. Used to
3429 -- provide better messages on common visiblity errors on operators.
3431 function Universal_Interpretation
(Opnd
: Node_Id
) return Entity_Id
;
3432 -- Yields Universal_Integer or Universal_Real if this is a candidate
3434 function Unqualify
(Expr
: Node_Id
) return Node_Id
;
3435 pragma Inline
(Unqualify
);
3436 -- Removes any qualifications from Expr. For example, for T1'(T2'(X)), this
3437 -- returns X. If Expr is not a qualified expression, returns Expr.
3439 function Unqual_Conv
(Expr
: Node_Id
) return Node_Id
;
3440 pragma Inline
(Unqual_Conv
);
3441 -- Similar to Unqualify, but removes qualified expressions, type
3442 -- conversions, and unchecked conversions.
3444 function Validated_View
(Typ
: Entity_Id
) return Entity_Id
;
3445 -- Obtain the "validated view" of arbitrary type Typ which is suitable for
3446 -- verification by attribute 'Valid_Scalars. This view is the type itself
3447 -- or its full view while stripping away concurrency, derivations, and
3450 function Visible_Ancestors
(Typ
: Entity_Id
) return Elist_Id
;
3451 -- [Ada 2012:AI-0125-1]: Collect all the visible parents and progenitors
3452 -- of a type extension or private extension declaration. If the full-view
3453 -- of private parents and progenitors is available then it is used to
3454 -- generate the list of visible ancestors; otherwise their partial
3455 -- view is added to the resulting list.
3457 function Within_Init_Proc
return Boolean;
3458 -- Determines if Current_Scope is within an init proc
3460 function Within_Protected_Type
(E
: Entity_Id
) return Boolean;
3461 -- Returns True if entity E is declared within a protected type
3463 function Within_Scope
(E
: Entity_Id
; S
: Entity_Id
) return Boolean;
3464 -- Returns True if entity E is declared within scope S
3466 procedure Warn_On_Hiding_Entity
3468 Hidden
, Visible
: Entity_Id
;
3469 On_Use_Clause
: Boolean);
3470 -- Warn on hiding of an entity, either because a new declaration hides
3471 -- an entity directly visible or potentially visible through a use_clause
3472 -- (On_Use_Clause = False), or because the entity would be potentially
3473 -- visible through a use_clause if it was now hidden by a visible
3474 -- declaration (On_Use_Clause = True). N is the node on which the warning
3475 -- is potentially issued: it is the visible entity in the former case, and
3476 -- the use_clause in the latter case.
3478 procedure Wrong_Type
(Expr
: Node_Id
; Expected_Type
: Entity_Id
);
3479 -- Output error message for incorrectly typed expression. Expr is the node
3480 -- for the incorrectly typed construct (Etype (Expr) is the type found),
3481 -- and Expected_Type is the entity for the expected type. Note that Expr
3482 -- does not have to be a subexpression, anything with an Etype field may
3485 function Yields_Synchronized_Object
(Typ
: Entity_Id
) return Boolean;
3486 -- Determine whether type Typ "yields synchronized object" as specified by
3487 -- SPARK RM 9.1. To qualify as such, a type must be
3488 -- * An array type whose element type yields a synchronized object
3489 -- * A descendant of type Ada.Synchronous_Task_Control.Suspension_Object
3490 -- * A protected type
3491 -- * A record type or type extension without defaulted discriminants
3492 -- whose components are of a type that yields a synchronized object.
3493 -- * A synchronized interface type
3496 function Yields_Universal_Type
(N
: Node_Id
) return Boolean;
3497 -- Determine whether unanalyzed node N yields a universal type
3499 procedure Preanalyze_Without_Errors
(N
: Node_Id
);
3500 -- Preanalyze N without reporting errors
3502 package Interval_Lists
is
3503 type Discrete_Interval
is
3508 type Discrete_Interval_List
is
3509 array (Pos
range <>) of Discrete_Interval
;
3510 -- A sorted (in ascending order) list of non-empty pairwise-disjoint
3511 -- intervals, always with a gap of at least one value between
3512 -- successive intervals (i.e., mergeable intervals are merged).
3513 -- Low bound is one; high bound is nonnegative.
3515 function Aggregate_Intervals
(N
: Node_Id
) return Discrete_Interval_List
;
3516 -- Given an array aggregate N, returns the (unique) interval list
3517 -- representing the values of the aggregate choices; if all the array
3518 -- components are covered by the others choice then the length of the
3521 function Choice_List_Intervals
3522 (Discrete_Choices
: List_Id
) return Discrete_Interval_List
;
3523 -- Given a discrete choice list, returns the (unique) interval
3524 -- list representing the chosen values.
3526 function Type_Intervals
(Typ
: Entity_Id
) return Discrete_Interval_List
;
3527 -- Given a static discrete type or subtype, returns the (unique)
3528 -- interval list representing the values of the type/subtype.
3529 -- If no static predicates are involved, the length of the result
3530 -- will be at most one.
3532 function Is_Subset
(Subset
, Of_Set
: Discrete_Interval_List
)
3534 -- Returns True iff every value belonging to some interval of
3535 -- Subset also belongs to some interval of Of_Set.
3537 -- When we get around to implementing "is statically compatible"
3538 -- correctly for real types with static predicates, we may need
3539 -- an analogous Real_Interval_List type. Most of the language
3540 -- rules that reference "is statically compatible" pertain to
3541 -- discriminants and therefore do not require support for real types;
3542 -- the exception is 12.5.1(8).
3544 Intervals_Error
: exception;
3545 -- Raised when the list of non-empty pair-wise disjoint intervals cannot
3549 package Old_Attr_Util
is
3550 -- Operations related to 'Old attribute evaluation. This
3551 -- includes cases where a level of indirection is needed due to
3552 -- conditional evaluation as well as support for the
3553 -- "known on entry" rules.
3555 package Conditional_Evaluation
is
3556 function Eligible_For_Conditional_Evaluation
3557 (Expr
: Node_Id
) return Boolean;
3558 -- Given a subexpression of a Postcondition expression
3559 -- (typically a 'Old attribute reference), returns True if
3560 -- - the expression is conditionally evaluated; and
3561 -- - its determining expressions are all known on entry; and
3562 -- - Ada_Version >= Ada_2022.
3563 -- See RM 6.1.1 for definitions of these terms.
3565 -- Also returns True if Expr is of an anonymous access type;
3566 -- this is just because we want the code that knows how to build
3567 -- 'Old temps in that case to reside in only one place.
3569 function Conditional_Evaluation_Condition
3570 (Expr
: Node_Id
) return Node_Id
;
3571 -- Given an expression which is eligible for conditional evaluation,
3572 -- build a Boolean expression whose value indicates whether the
3573 -- expression should be evaluated.
3574 end Conditional_Evaluation
;
3576 package Indirect_Temps
is
3578 with procedure Append_Item
(N
: Node_Id
; Is_Eval_Stmt
: Boolean);
3579 -- If Is_Eval_Stmt is True, then N is a statement that should
3580 -- only be executed in the case where the 'Old prefix is to be
3581 -- evaluated. If Is_Eval_Stmt is False, then N is a declaration
3582 -- which should be elaborated unconditionally.
3583 -- Client is responsible for ensuring that any appended
3584 -- Eval_Stmt nodes are eventually analyzed.
3586 Append_Decls_In_Reverse_Order
: Boolean := False;
3587 -- This parameter is for the convenience of exp_prag.adb, where we
3588 -- want to Prepend rather than Append so it is better to get the
3589 -- Append calls in reverse order.
3591 procedure Declare_Indirect_Temp
3592 (Attr_Prefix
: Node_Id
; -- prefix of 'Old attribute (or similar?)
3593 Indirect_Temp
: out Entity_Id
);
3594 -- Indirect_Temp is of an access type; it is unconditionally
3595 -- declared but only conditionally initialized to reference the
3596 -- saved value of Attr_Prefix.
3598 function Indirect_Temp_Needed
(Typ
: Entity_Id
) return Boolean;
3599 -- Returns True for a specific tagged type because the temp must
3600 -- be of the class-wide type in order to preserve the underlying tag.
3602 -- Also returns True in the case of an anonymous access type
3603 -- because we want the code that knows how to deal with
3604 -- this case to reside in only one place.
3606 -- For an unconstrained-but-definite discriminated subtype, returns
3607 -- True if the potential difference in size between an
3608 -- unconstrained object and a constrained object is large.
3609 -- [This part is not implemented yet.]
3611 -- Otherwise, returns False if a declaration of the form
3613 -- is legal and side-effect-free (assuming that default
3614 -- initialization is suppressed). For example, returns True if Typ is
3615 -- indefinite, or if Typ has a controlled part.
3618 function Indirect_Temp_Value
3621 Loc
: Source_Ptr
) return Node_Id
;
3622 -- Evaluate a temp declared by Declare_Indirect_Temp.
3624 function Is_Access_Type_For_Indirect_Temp
3625 (T
: Entity_Id
) return Boolean;
3626 -- True for an access type that was declared via a call
3627 -- to Declare_Indirect_Temp.
3628 -- Indicates that the given access type should be treated
3629 -- the same with respect to finalization as a
3630 -- user-defined "comes from source" access type.
3635 package Storage_Model_Support
is
3637 -- This package provides a set of utility functions related to support
3638 -- for the Storage_Model feature. These functions provide an interface
3639 -- that the compiler (in particular back-end phases such as gigi and
3640 -- GNAT-LLVM) can use to easily obtain entities and operations that
3641 -- are specified for types that have aspects Storage_Model_Type or
3642 -- Designated_Storage_Model.
3644 function Has_Storage_Model_Type_Aspect
(Typ
: Entity_Id
) return Boolean;
3645 -- Returns True iff Typ specifies aspect Storage_Model_Type
3647 function Has_Designated_Storage_Model_Aspect
3648 (Typ
: Entity_Id
) return Boolean;
3649 -- Returns True iff Typ specifies aspect Designated_Storage_Model
3651 function Storage_Model_Object
(Typ
: Entity_Id
) return Entity_Id
;
3652 -- Given an access type Typ with aspect Designated_Storage_Model,
3653 -- returns the storage-model object associated with that type.
3654 -- The object Entity_Ids returned by this function can be passed
3655 -- other functions declared in this interface to retrieve operations
3656 -- associated with Storage_Model_Type aspect of the object's type.
3658 function Storage_Model_Type
(Obj
: Entity_Id
) return Entity_Id
;
3659 -- Given an object Obj of a type specifying aspect Storage_Model_Type,
3660 -- returns that type.
3662 function Get_Storage_Model_Type_Entity
3663 (SM_Obj_Or_Type
: Entity_Id
;
3664 Nam
: Name_Id
) return Entity_Id
;
3665 -- Given a type with aspect Storage_Model_Type or an object of such a
3666 -- type, and Nam denoting the name of one of the argument kinds allowed
3667 -- for that aspect, returns the Entity_Id corresponding to the entity
3668 -- associated with Nam in the aspect. If such an entity is not present,
3669 -- then returns Empty. (Note: This function is modeled on function
3670 -- Get_Iterable_Type_Primitive.)
3672 function Storage_Model_Address_Type
3673 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3674 -- Given a type with aspect Storage_Model_Type or an object of such a
3675 -- type, returns the type specified for the Address_Type choice in that
3676 -- aspect; returns Empty if the type isn't specified.
3678 function Storage_Model_Null_Address
3679 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3680 -- Given a type with aspect Storage_Model_Type or an object of such a
3681 -- type, returns the constant specified for the Null_Address choice in
3682 -- that aspect; returns Empty if the constant object isn't specified.
3684 function Storage_Model_Allocate
3685 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3686 -- Given a type with aspect Storage_Model_Type or an object of such a
3687 -- type, returns the procedure specified for the Allocate choice in that
3688 -- aspect; returns Empty if the procedure isn't specified.
3690 function Storage_Model_Deallocate
3691 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3692 -- Given a type with aspect Storage_Model_Type or an object of such a
3693 -- type, returns the procedure specified for the Deallocate choice in
3694 -- that aspect; returns Empty if the procedure isn't specified.
3696 function Storage_Model_Copy_From
3697 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3698 -- Given a type with aspect Storage_Model_Type or an object of such a
3699 -- type, returns the procedure specified for the Copy_From choice in
3700 -- that aspect; returns Empty if the procedure isn't specified.
3702 function Storage_Model_Copy_To
3703 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3704 -- Given a type with aspect Storage_Model_Type or an object of such a
3705 -- type, returns the procedure specified for the Copy_To choice in that
3706 -- aspect; returns Empty if the procedure isn't specified.
3708 function Storage_Model_Storage_Size
3709 (SM_Obj_Or_Type
: Entity_Id
) return Entity_Id
;
3710 -- Given a type with aspect Storage_Model_Type or an object of such a
3711 -- type, returns the function specified for the Storage_Size choice in
3712 -- that aspect; returns Empty if the procedure isn't specified.
3714 end Storage_Model_Support
;