1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2021, 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_Discriminal_Subtype_Of_Component
324 (T
: Entity_Id
) return Node_Id
;
325 -- Determine whether a record component has a type that depends on
326 -- discriminants, and build actual subtype for it if so.
328 procedure Build_Elaboration_Entity
(N
: Node_Id
; Spec_Id
: Entity_Id
);
329 -- Given a compilation unit node N, allocate an elaboration counter for
330 -- the compilation unit, and install it in the Elaboration_Entity field
331 -- of Spec_Id, the entity for the compilation unit.
333 procedure Build_Explicit_Dereference
336 -- AI05-139: Names with implicit dereference. If the expression N is a
337 -- reference type and the context imposes the corresponding designated
338 -- type, convert N into N.Disc.all. Such expressions are always over-
339 -- loaded with both interpretations, and the dereference interpretation
340 -- carries the name of the reference discriminant.
342 function Build_Overriding_Spec
344 Typ
: Entity_Id
) return Node_Id
;
345 -- Build a subprogram specification for the wrapper of an inherited
346 -- operation with a modified pre- or postcondition (See AI12-0113).
347 -- Op is the parent operation, and Typ is the descendant type that
348 -- inherits the operation.
350 function Build_Subtype
351 (Related_Node
: Node_Id
;
354 Constraints
: List_Id
)
356 -- Typ is an array or discriminated type, Constraints is a list of
357 -- constraints that apply to Typ. This routine builds the constrained
358 -- subtype using Loc as the source location and attached this subtype
359 -- declaration to Related_Node. The returned subtype inherits predicates
362 -- ??? The routine is mostly a duplicate of Build_Constrained_Itype, so be
363 -- careful which of the two better suits your needs (and certainly do not
364 -- duplicate their code).
366 function Cannot_Raise_Constraint_Error
(Expr
: Node_Id
) return Boolean;
367 -- Returns True if the expression cannot possibly raise Constraint_Error.
368 -- The response is conservative in the sense that a result of False does
369 -- not necessarily mean that CE could be raised, but a response of True
370 -- means that for sure CE cannot be raised.
372 procedure Check_Ambiguous_Aggregate
(Call
: Node_Id
);
373 -- Additional information on an ambiguous call in Ada_2022 when a
374 -- subprogram call has an actual that is an aggregate, and the
375 -- presence of container aggregates (or types with the corresponding
376 -- aspect) provides an additional interpretation. Message indicates
377 -- that an aggregate actual should carry a type qualification.
379 procedure Check_Dynamically_Tagged_Expression
382 Related_Nod
: Node_Id
);
383 -- Check wrong use of dynamically tagged expression
385 procedure Check_Fully_Declared
(T
: Entity_Id
; N
: Node_Id
);
386 -- Verify that the full declaration of type T has been seen. If not, place
387 -- error message on node N. Used in object declarations, type conversions
388 -- and qualified expressions.
390 procedure Check_Function_With_Address_Parameter
(Subp_Id
: Entity_Id
);
391 -- A subprogram that has an Address parameter and is declared in a Pure
392 -- package is not considered Pure, because the parameter may be used as a
393 -- pointer and the referenced data may change even if the address value
395 -- If the programmer gave an explicit Pure_Function pragma, then we respect
396 -- the pragma and leave the subprogram Pure.
398 procedure Check_Function_Writable_Actuals
(N
: Node_Id
);
399 -- (Ada 2012): If the construct N has two or more direct constituents that
400 -- are names or expressions whose evaluation may occur in an arbitrary
401 -- order, at least one of which contains a function call with an in out or
402 -- out parameter, then the construct is legal only if: for each name that
403 -- is passed as a parameter of mode in out or out to some inner function
404 -- call C2 (not including the construct N itself), there is no other name
405 -- anywhere within a direct constituent of the construct C other than
406 -- the one containing C2, that is known to refer to the same object (RM
409 procedure Check_Implicit_Dereference
(N
: Node_Id
; Typ
: Entity_Id
);
410 -- AI05-139-2: Accessors and iterators for containers. This procedure
411 -- checks whether T is a reference type, and if so it adds an interprettion
412 -- to N whose type is the designated type of the reference_discriminant.
413 -- If N is a generalized indexing operation, the interpretation is added
414 -- both to the corresponding function call, and to the indexing node.
416 procedure Check_Internal_Protected_Use
(N
: Node_Id
; Nam
: Entity_Id
);
417 -- Within a protected function, the current object is a constant, and
418 -- internal calls to a procedure or entry are illegal. Similarly, other
419 -- uses of a protected procedure in a renaming or a generic instantiation
420 -- in the context of a protected function are illegal (AI05-0225).
422 procedure Check_Later_Vs_Basic_Declarations
424 During_Parsing
: Boolean);
425 -- If During_Parsing is True, check for misplacement of later vs basic
426 -- declarations in Ada 83. If During_Parsing is False, and the SPARK
427 -- restriction is set, do the same: although SPARK 95 removes the
428 -- distinction between initial and later declarative items, the distinction
429 -- remains in the Examiner (JB01-005). Note that the Examiner does not
430 -- count package declarations in later declarative items.
432 procedure Check_No_Hidden_State
(Id
: Entity_Id
);
433 -- Determine whether object or state Id introduces a hidden state. If this
434 -- is the case, emit an error.
436 procedure Check_Inherited_Nonoverridable_Aspects
437 (Inheritor
: Entity_Id
;
438 Interface_List
: List_Id
;
439 Parent_Type
: Entity_Id
);
440 -- Verify consistency of inherited nonoverridable aspects
441 -- when aspects are inherited from more than one source.
442 -- Parent_Type may be void (e.g., for a tagged task/protected type
443 -- whose declaration includes a non-empty interface list).
444 -- In the error case, error message is associate with Inheritor;
445 -- Inheritor parameter is otherwise unused.
447 procedure Check_Nonvolatile_Function_Profile
(Func_Id
: Entity_Id
);
448 -- Verify that the profile of nonvolatile function Func_Id does not contain
449 -- effectively volatile parameters or return type for reading.
451 procedure Check_Part_Of_Reference
(Var_Id
: Entity_Id
; Ref
: Node_Id
);
452 -- Verify the legality of reference Ref to variable Var_Id when the
453 -- variable is a constituent of a single protected/task type.
455 procedure Check_Potentially_Blocking_Operation
(N
: Node_Id
);
456 -- N is one of the statement forms that is a potentially blocking
457 -- operation. If it appears within a protected action, emit warning.
459 procedure Check_Previous_Null_Procedure
462 -- A null procedure or a subprogram renaming can complete a previous
463 -- declaration, unless that previous declaration is itself a null
464 -- procedure. This must be treated specially because the analysis of
465 -- the null procedure leaves the corresponding entity as having no
466 -- completion, because its completion is provided by a generated body
467 -- inserted after all other declarations.
469 procedure Check_Result_And_Post_State
(Subp_Id
: Entity_Id
);
470 -- Determine whether the contract of subprogram Subp_Id mentions attribute
471 -- 'Result and it contains an expression that evaluates differently in pre-
474 procedure Check_State_Refinements
476 Is_Main_Unit
: Boolean := False);
477 -- Verify that all abstract states declared in a block statement, entry
478 -- body, package body, protected body, subprogram body, task body, or a
479 -- package declaration denoted by Context have proper refinement. Emit an
480 -- error if this is not the case. Flag Is_Main_Unit should be set when
481 -- Context denotes the main compilation unit.
483 procedure Check_Unused_Body_States
(Body_Id
: Entity_Id
);
484 -- Verify that all abstract states and objects declared in the state space
485 -- of package body Body_Id are used as constituents. Emit an error if this
488 procedure Check_Unprotected_Access
491 -- Check whether the expression is a pointer to a protected component,
492 -- and the context is external to the protected operation, to warn against
493 -- a possible unlocked access to data.
495 procedure Check_Volatility_Compatibility
496 (Id1
, Id2
: Entity_Id
;
497 Description_1
, Description_2
: String;
498 Srcpos_Bearer
: Node_Id
);
499 -- Id1 and Id2 should each be the entity of a state abstraction, a
500 -- variable, or a type (i.e., something suitable for passing to
501 -- Async_Readers_Enabled and similar functions).
502 -- Does nothing if SPARK_Mode /= On. Otherwise, flags a legality violation
503 -- if one or more of the four volatility-related aspects is False for Id1
504 -- and True for Id2. The two descriptions are included in the error message
505 -- text; the source position for the generated message is determined by
508 function Choice_List
(N
: Node_Id
) return List_Id
;
509 -- Utility to retrieve the choices of a Component_Association or the
510 -- Discrete_Choices of an Iterated_Component_Association. For various
511 -- reasons these nodes have a different structure even though they play
512 -- similar roles in array aggregates.
514 type Condition_Kind
is
515 (Ignored_Class_Precondition
,
516 Ignored_Class_Postcondition
,
518 Class_Postcondition
);
519 -- Kind of class-wide conditions
521 function Class_Condition
522 (Kind
: Condition_Kind
;
523 Subp
: Entity_Id
) return Node_Id
;
524 -- Class-wide Kind condition of Subp
526 function Collect_Body_States
(Body_Id
: Entity_Id
) return Elist_Id
;
527 -- Gather the entities of all abstract states and objects declared in the
528 -- body state space of package body Body_Id.
530 procedure Collect_Interfaces
532 Ifaces_List
: out Elist_Id
;
533 Exclude_Parents
: Boolean := False;
534 Use_Full_View
: Boolean := True);
535 -- Ada 2005 (AI-251): Collect whole list of abstract interfaces that are
536 -- directly or indirectly implemented by T. Exclude_Parents is used to
537 -- avoid the addition of inherited interfaces to the generated list.
538 -- Use_Full_View is used to collect the interfaces using the full-view
541 procedure Collect_Interface_Components
542 (Tagged_Type
: Entity_Id
;
543 Components_List
: out Elist_Id
);
544 -- Ada 2005 (AI-251): Collect all the tag components associated with the
545 -- secondary dispatch tables of a tagged type.
547 procedure Collect_Interfaces_Info
549 Ifaces_List
: out Elist_Id
;
550 Components_List
: out Elist_Id
;
551 Tags_List
: out Elist_Id
);
552 -- Ada 2005 (AI-251): Collect all the interfaces associated with T plus
553 -- the record component and tag associated with each of these interfaces.
554 -- On exit Ifaces_List, Components_List and Tags_List have the same number
555 -- of elements, and elements at the same position on these tables provide
556 -- information on the same interface type.
558 procedure Collect_Parents
561 Use_Full_View
: Boolean := True);
562 -- Collect all the parents of Typ. Use_Full_View is used to collect them
563 -- using the full-view of private parents (if available).
565 function Collect_Primitive_Operations
(T
: Entity_Id
) return Elist_Id
;
566 -- Called upon type derivation and extension. We scan the declarative part
567 -- in which the type appears, and collect subprograms that have one
568 -- subsidiary subtype of the type. These subprograms can only appear after
571 function Compile_Time_Constraint_Error
574 Ent
: Entity_Id
:= Empty
;
575 Loc
: Source_Ptr
:= No_Location
;
576 Warn
: Boolean := False;
577 Extra_Msg
: String := "") return Node_Id
;
578 -- This is similar to Apply_Compile_Time_Constraint_Error in that it
579 -- generates a warning (or error) message in the same manner, but it does
580 -- not replace any nodes. For convenience, the function always returns its
581 -- first argument. The message is a warning if the message ends with ?, or
582 -- we are operating in Ada 83 mode, or the Warn parameter is set to True.
583 -- If Extra_Msg is not a null string, then it's associated with N and
584 -- emitted immediately after the main message (and before output of any
585 -- message indicating that Constraint_Error will be raised).
587 procedure Compute_Returns_By_Ref
(Func
: Entity_Id
);
588 -- Set the Returns_By_Ref flag on Func if appropriate
591 with function Predicate
(Typ
: Entity_Id
) return Boolean;
592 function Collect_Types_In_Hierarchy
594 Examine_Components
: Boolean := False) return Elist_Id
;
595 -- Inspect the ancestor and progenitor types of Typ and Typ itself -
596 -- collecting those for which function Predicate is True. The resulting
597 -- list is ordered in a type-to-ultimate-ancestor fashion.
599 -- When Examine_Components is True, components types in the hierarchy also
602 procedure Conditional_Delay
(New_Ent
, Old_Ent
: Entity_Id
);
603 -- Sets the Has_Delayed_Freeze flag of New_Ent if the Delayed_Freeze flag
604 -- of Old_Ent is set and Old_Ent has not yet been Frozen (i.e. Is_Frozen is
607 function Copy_Component_List
609 Loc
: Source_Ptr
) return List_Id
;
610 -- Copy components from record type R_Typ that come from source. Used to
611 -- create a new compatible record type. Loc is the source location assigned
612 -- to the created nodes.
614 function Copy_Parameter_List
(Subp_Id
: Entity_Id
) return List_Id
;
615 -- Utility to create a parameter profile for a new subprogram spec, when
616 -- the subprogram has a body that acts as spec. This is done for some cases
617 -- of inlining, and for private protected ops. Also used to create bodies
618 -- for stubbed subprograms.
620 procedure Copy_SPARK_Mode_Aspect
(From
: Node_Id
; To
: Node_Id
);
621 -- Copy the SPARK_Mode aspect if present in the aspect specifications
622 -- of node From to node To. On entry it is assumed that To does not have
623 -- aspect specifications. If From has no aspects, the routine has no
626 function Copy_Subprogram_Spec
(Spec
: Node_Id
) return Node_Id
;
627 -- Replicate a function or a procedure specification denoted by Spec. The
628 -- resulting tree is an exact duplicate of the original tree. New entities
629 -- are created for the unit name and the formal parameters.
631 function Corresponding_Generic_Type
(T
: Entity_Id
) return Entity_Id
;
632 -- If a type is a generic actual type, return the corresponding formal in
633 -- the generic parent unit. There is no direct link in the tree for this
634 -- attribute, except in the case of formal private and derived types.
635 -- Possible optimization???
637 function Corresponding_Primitive_Op
638 (Ancestor_Op
: Entity_Id
;
639 Descendant_Type
: Entity_Id
) return Entity_Id
;
640 -- Given a primitive subprogram of a tagged type and a (distinct)
641 -- descendant type of that type, find the corresponding primitive
642 -- subprogram of the descendant type.
644 function Current_Entity
(N
: Node_Id
) return Entity_Id
;
645 pragma Inline
(Current_Entity
);
646 -- Find the currently visible definition for a given identifier, that is to
647 -- say the first entry in the visibility chain for the Chars of N.
649 function Current_Entity_In_Scope
(N
: Name_Id
) return Entity_Id
;
650 function Current_Entity_In_Scope
(N
: Node_Id
) return Entity_Id
;
651 -- Find whether there is a previous definition for name or identifier N in
652 -- the current scope. Because declarations for a scope are not necessarily
653 -- contiguous (e.g. for packages) the first entry on the visibility chain
654 -- for N is not necessarily in the current scope.
656 function Current_Scope
return Entity_Id
;
657 -- Get entity representing current scope
659 function Current_Scope_No_Loops
return Entity_Id
;
660 -- Return the current scope ignoring internally generated loops
662 function Current_Subprogram
return Entity_Id
;
663 -- Returns current enclosing subprogram. If Current_Scope is a subprogram,
664 -- then that is what is returned, otherwise the Enclosing_Subprogram of the
665 -- Current_Scope is returned. The returned value is Empty if this is called
666 -- from a library package which is not within any subprogram.
668 function CW_Or_Has_Controlled_Part
(T
: Entity_Id
) return Boolean;
669 -- True if T is a class-wide type, or if it has controlled parts ("part"
670 -- means T or any of its subcomponents). Same as Needs_Finalization, except
671 -- when pragma Restrictions (No_Finalization) applies, in which case we
672 -- know that class-wide objects do not contain controlled parts.
674 function Deepest_Type_Access_Level
676 Allow_Alt_Model
: Boolean := True) return Uint
;
678 -- Same as Type_Access_Level, except that if the type is the type of an Ada
679 -- 2012 stand-alone object of an anonymous access type, then return the
680 -- static accessibility level of the object. In that case, the dynamic
681 -- accessibility level of the object may take on values in a range. The low
682 -- bound of that range is returned by Type_Access_Level; this function
683 -- yields the high bound of that range. Also differs from Type_Access_Level
684 -- in the case of a descendant of a generic formal type (returns Int'Last
687 -- The Allow_Alt_Model parameter allows the alternative level calculation
688 -- under the restriction No_Dynamic_Accessibility_Checks to be performed.
690 function Defining_Entity
(N
: Node_Id
) return Entity_Id
;
691 -- Given a declaration N, returns the associated defining entity. If the
692 -- declaration has a specification, the entity is obtained from the
693 -- specification. If the declaration has a defining unit name, then the
694 -- defining entity is obtained from the defining unit name ignoring any
695 -- child unit prefixes.
697 -- Iterator loops also have a defining entity, which holds the list of
698 -- local entities declared during loop expansion. These entities need
699 -- debugging information, generated through Qualify_Entity_Names, and
700 -- the loop declaration must be placed in the table Name_Qualify_Units.
702 -- WARNING: There is a matching C declaration of this subprogram in fe.h
704 function Defining_Entity_Or_Empty
(N
: Node_Id
) return Entity_Id
;
705 -- This is equivalent to Defining_Entity but it returns Empty for nodes
706 -- without an entity instead of raising Program_Error.
708 function Denotes_Discriminant
710 Check_Concurrent
: Boolean := False) return Boolean;
711 -- Returns True if node N is an Entity_Name node for a discriminant. If the
712 -- flag Check_Concurrent is true, function also returns true when N denotes
713 -- the discriminal of the discriminant of a concurrent type. This is needed
714 -- to disable some optimizations on private components of protected types,
715 -- and constraint checks on entry families constrained by discriminants.
717 function Denotes_Same_Object
(A1
, A2
: Node_Id
) return Boolean;
718 -- Detect suspicious overlapping between actuals in a call, when both are
719 -- writable (RM 2012 6.4.1(6.4/3)).
721 function Denotes_Same_Prefix
(A1
, A2
: Node_Id
) return Boolean;
722 -- Functions to detect suspicious overlapping between actuals in a call,
723 -- when one of them is writable. The predicates are those proposed in
724 -- AI05-0144, to detect dangerous order dependence in complex calls.
725 -- I would add a parameter Warn which enables more extensive testing of
726 -- cases as we find appropriate when we are only warning ??? Or perhaps
727 -- return an indication of (Error, Warn, OK) ???
729 function Denotes_Variable
(N
: Node_Id
) return Boolean;
730 -- Returns True if node N denotes a single variable without parentheses
732 function Depends_On_Discriminant
(N
: Node_Id
) return Boolean;
733 -- Returns True if N denotes a discriminant or if N is a range, a subtype
734 -- indication or a scalar subtype where one of the bounds is a
737 function Derivation_Too_Early_To_Inherit
738 (Typ
: Entity_Id
; Streaming_Op
: TSS_Name_Type
) return Boolean;
739 -- Returns True if Typ is a derived type, the given Streaming_Op
740 -- (one of Read, Write, Input, or Output) is explicitly specified
741 -- for Typ's parent type, and that attribute specification is *not*
742 -- inherited by Typ because the declaration of Typ precedes that
743 -- of the attribute specification.
745 function Designate_Same_Unit
747 Name2
: Node_Id
) return Boolean;
748 -- Returns True if Name1 and Name2 designate the same unit name; each of
749 -- these names is supposed to be a selected component name, an expanded
750 -- name, a defining program unit name or an identifier.
752 procedure Diagnose_Iterated_Component_Association
(N
: Node_Id
);
753 -- Emit an error if iterated component association N is actually an illegal
754 -- quantified expression lacking a quantifier.
756 function Discriminated_Size
(Comp
: Entity_Id
) return Boolean;
757 -- If a component size is not static then a warning will be emitted
758 -- in Ravenscar or other restricted contexts. When a component is non-
759 -- static because of a discriminant constraint we can specialize the
760 -- warning by mentioning discriminants explicitly. This was created for
761 -- private components of protected objects, but is generally useful when
762 -- restriction No_Implicit_Heap_Allocation is active.
764 function Effective_Extra_Accessibility
(Id
: Entity_Id
) return Entity_Id
;
765 -- Same as Einfo.Extra_Accessibility except thtat object renames
766 -- are looked through.
768 function Effective_Reads_Enabled
(Id
: Entity_Id
) return Boolean;
769 -- Id should be the entity of a state abstraction, an object, or a type.
770 -- Returns True iff Id is subject to external property Effective_Reads.
772 function Effective_Writes_Enabled
(Id
: Entity_Id
) return Boolean;
773 -- Id should be the entity of a state abstraction, an object, or a type.
774 -- Returns True iff Id is subject to external property Effective_Writes.
776 function Enclosing_Comp_Unit_Node
(N
: Node_Id
) return Node_Id
;
777 -- Returns the enclosing N_Compilation_Unit node that is the root of a
778 -- subtree containing N.
780 function Enclosing_CPP_Parent
(Typ
: Entity_Id
) return Entity_Id
;
781 -- Returns the closest ancestor of Typ that is a CPP type.
783 function Enclosing_Declaration
(N
: Node_Id
) return Node_Id
;
784 -- Returns the declaration node enclosing N (including possibly N itself),
785 -- if any, or Empty otherwise.
787 function Enclosing_Generic_Body
(N
: Node_Id
) return Node_Id
;
788 -- Returns the Node_Id associated with the innermost enclosing generic
789 -- body, if any. If none, then returns Empty.
791 function Enclosing_Generic_Unit
(N
: Node_Id
) return Node_Id
;
792 -- Returns the Node_Id associated with the innermost enclosing generic
793 -- unit, if any. If none, then returns Empty.
795 function Enclosing_HSS
(Stmt
: Node_Id
) return Node_Id
;
796 -- Returns the nearest handled sequence of statements that encloses a given
797 -- statement, or Empty.
799 function Enclosing_Lib_Unit_Entity
800 (E
: Entity_Id
:= Current_Scope
) return Entity_Id
;
801 -- Returns the entity of enclosing library unit node which is the root of
802 -- the current scope (which must not be Standard_Standard, and the caller
803 -- is responsible for ensuring this condition) or other specified entity.
805 function Enclosing_Lib_Unit_Node
(N
: Node_Id
) return Node_Id
;
806 -- Returns the N_Compilation_Unit node of the library unit that is directly
807 -- or indirectly (through a subunit) at the root of a subtree containing
808 -- N. This may be either the same as Enclosing_Comp_Unit_Node, or if
809 -- Enclosing_Comp_Unit_Node returns a subunit, then the corresponding
810 -- library unit. If no such item is found, returns Empty.
812 function Enclosing_Package
(E
: Entity_Id
) return Entity_Id
;
813 -- Utility function to return the Ada entity of the package enclosing
814 -- the entity E, if any. Returns Empty if no enclosing package.
816 function Enclosing_Package_Or_Subprogram
(E
: Entity_Id
) return Entity_Id
;
817 -- Returns the entity of the package or subprogram enclosing E, if any.
818 -- Returns Empty if no enclosing package or subprogram.
820 function Enclosing_Subprogram
(E
: Entity_Id
) return Entity_Id
;
821 -- Utility function to return the Ada entity of the subprogram enclosing
822 -- the entity E, if any. Returns Empty if no enclosing subprogram.
824 function End_Keyword_Location
(N
: Node_Id
) return Source_Ptr
;
825 -- Given block statement, entry body, package body, package declaration,
826 -- protected body, [single] protected type declaration, subprogram body,
827 -- task body, or [single] task type declaration N, return the closest
828 -- source location of the "end" keyword.
830 procedure Ensure_Freeze_Node
(E
: Entity_Id
);
831 -- Make sure a freeze node is allocated for entity E. If necessary, build
832 -- and initialize a new freeze node and set Has_Delayed_Freeze True for E.
834 procedure Enter_Name
(Def_Id
: Entity_Id
);
835 -- Insert new name in symbol table of current scope with check for
836 -- duplications (error message is issued if a conflict is found).
837 -- Note: Enter_Name is not used for overloadable entities, instead these
838 -- are entered using Sem_Ch6.Enter_Overloaded_Entity.
840 function Entity_Of
(N
: Node_Id
) return Entity_Id
;
841 -- Obtain the entity of arbitrary node N. If N is a renaming, return the
842 -- entity of the earliest renamed source abstract state or whole object.
843 -- If no suitable entity is available, return Empty. This routine carries
844 -- out actions that are tied to SPARK semantics.
846 function Exceptions_OK
return Boolean;
847 -- Determine whether exceptions are allowed to be caught, propagated, or
850 procedure Explain_Limited_Type
(T
: Entity_Id
; N
: Node_Id
);
851 -- This procedure is called after issuing a message complaining about an
852 -- inappropriate use of limited type T. If useful, it adds additional
853 -- continuation lines to the message explaining why type T is limited.
854 -- Messages are placed at node N.
856 function Expression_Of_Expression_Function
857 (Subp
: Entity_Id
) return Node_Id
;
858 -- Return the expression of expression function Subp
860 type Extensions_Visible_Mode
is
861 (Extensions_Visible_None
,
862 -- Extensions_Visible does not yield a mode when SPARK_Mode is off. This
863 -- value acts as a default in a non-SPARK compilation.
865 Extensions_Visible_False
,
866 -- A value of "False" signifies that Extensions_Visible is either
867 -- missing or the pragma is present and the value of its Boolean
868 -- expression is False.
870 Extensions_Visible_True
);
871 -- A value of "True" signifies that Extensions_Visible is present and
872 -- the value of its Boolean expression is True.
874 function Extensions_Visible_Status
875 (Id
: Entity_Id
) return Extensions_Visible_Mode
;
876 -- Given the entity of a subprogram or formal parameter subject to pragma
877 -- Extensions_Visible, return the Boolean value denoted by the expression
880 procedure Find_Actual
882 Formal
: out Entity_Id
;
884 -- Determines if the node N is an actual parameter of a function or a
885 -- procedure call. If so, then Formal points to the entity for the formal
886 -- (Ekind is E_In_Parameter, E_Out_Parameter, or E_In_Out_Parameter) and
887 -- Call is set to the node for the corresponding call. If the node N is not
888 -- an actual parameter then Formal and Call are set to Empty.
890 function Find_Body_Discriminal
891 (Spec_Discriminant
: Entity_Id
) return Entity_Id
;
892 -- Given a discriminant of the record type that implements a task or
893 -- protected type, return the discriminal of the corresponding discriminant
894 -- of the actual concurrent type.
896 function Find_Corresponding_Discriminant
898 Typ
: Entity_Id
) return Entity_Id
;
899 -- Because discriminants may have different names in a generic unit and in
900 -- an instance, they are resolved positionally when possible. A reference
901 -- to a discriminant carries the discriminant that it denotes when it is
902 -- analyzed. Subsequent uses of this id on a different type denotes the
903 -- discriminant at the same position in this new type.
905 function Find_DIC_Type
(Typ
: Entity_Id
) return Entity_Id
;
906 -- Subsidiary to all Build_DIC_Procedure_xxx routines. Find the type which
907 -- defines the Default_Initial_Condition pragma of type Typ. This is either
908 -- Typ itself or a parent type when the pragma is inherited.
910 function Find_Enclosing_Iterator_Loop
(Id
: Entity_Id
) return Entity_Id
;
911 -- Find the nearest iterator loop which encloses arbitrary entity Id. If
912 -- such a loop exists, return the entity of its identifier (E_Loop scope),
913 -- otherwise return Empty.
915 function Find_Enclosing_Scope
(N
: Node_Id
) return Entity_Id
;
916 -- Find the nearest scope which encloses arbitrary node N
918 function Find_Loop_In_Conditional_Block
(N
: Node_Id
) return Node_Id
;
919 -- Find the nested loop statement in a conditional block. Loops subject to
920 -- attribute 'Loop_Entry are transformed into blocks. Parts of the original
921 -- loop are nested within the block.
923 procedure Find_Overlaid_Entity
927 -- The node N should be an address representation clause. Determines if the
928 -- target expression is the address of an entity with an optional offset.
929 -- If so, set Ent to the entity and, if there is an offset, set Off to
930 -- True, otherwise to False. If it is not possible to determine that the
931 -- address is of this form, then set Ent to Empty.
933 function Find_Parameter_Type
(Param
: Node_Id
) return Entity_Id
;
934 -- Return the type of formal parameter Param as determined by its
937 -- The following type describes the placement of an arbitrary entity with
938 -- respect to SPARK visible / hidden state space.
940 type State_Space_Kind
is
942 -- An entity is not in the visible, private or body state space when
943 -- the immediate enclosing construct is not a package.
946 -- An entity is in the visible state space when it appears immediately
947 -- within the visible declarations of a package or when it appears in
948 -- the visible state space of a nested package which in turn is declared
949 -- in the visible declarations of an enclosing package:
952 -- Visible_Variable : ...
954 -- with Abstract_State => Visible_State
956 -- Visible_Nested_Variable : ...
960 -- Entities associated with a package instantiation inherit the state
961 -- space from the instance placement:
965 -- Generic_Variable : ...
970 -- package Inst is new Gen;
971 -- -- Generic_Variable is in the visible state space of Pack
975 -- An entity is in the private state space when it appears immediately
976 -- within the private declarations of a package or when it appears in
977 -- the visible state space of a nested package which in turn is declared
978 -- in the private declarations of an enclosing package:
982 -- Private_Variable : ...
984 -- with Abstract_State => Private_State
986 -- Private_Nested_Variable : ...
990 -- The same placement principle applies to package instantiations
993 -- An entity is in the body state space when it appears immediately
994 -- within the declarations of a package body or when it appears in the
995 -- visible state space of a nested package which in turn is declared in
996 -- the declarations of an enclosing package body:
998 -- package body Pack is
999 -- Body_Variable : ...
1001 -- with Abstract_State => Body_State
1003 -- Body_Nested_Variable : ...
1007 -- The same placement principle applies to package instantiations
1009 procedure Find_Placement_In_State_Space
1010 (Item_Id
: Entity_Id
;
1011 Placement
: out State_Space_Kind
;
1012 Pack_Id
: out Entity_Id
);
1013 -- Determine the state space placement of an item. Item_Id denotes the
1014 -- entity of an abstract state, object, or package instantiation. Placement
1015 -- captures the precise placement of the item in the enclosing state space.
1016 -- If the state space is that of a package, Pack_Id denotes its entity,
1017 -- otherwise Pack_Id is Empty.
1019 function Find_Primitive_Eq
(Typ
: Entity_Id
) return Entity_Id
;
1020 -- Locate primitive equality for type if it exists. Return Empty if it is
1023 function Find_Specific_Type
(CW
: Entity_Id
) return Entity_Id
;
1024 -- Find specific type of a class-wide type, and handle the case of an
1025 -- incomplete type coming either from a limited_with clause or from an
1026 -- incomplete type declaration. If resulting type is private return its
1029 function Find_Static_Alternative
(N
: Node_Id
) return Node_Id
;
1030 -- N is a case statement whose expression is a compile-time value.
1031 -- Determine the alternative chosen, so that the code of non-selected
1032 -- alternatives, and the warnings that may apply to them, are removed.
1034 function First_Actual
(Node
: Node_Id
) return Node_Id
;
1035 -- Node is an N_Function_Call, N_Procedure_Call_Statement or
1036 -- N_Entry_Call_Statement node. The result returned is the first actual
1037 -- parameter in declaration order (not the order of parameters as they
1038 -- appeared in the source, which can be quite different as a result of the
1039 -- use of named parameters). Empty is returned for a call with no
1040 -- parameters. The procedure for iterating through the actuals in
1041 -- declaration order is to use this function to find the first actual, and
1042 -- then use Next_Actual to obtain the next actual in declaration order.
1043 -- Note that the value returned is always the expression (not the
1044 -- N_Parameter_Association nodes, even if named association is used).
1046 -- WARNING: There is a matching C declaration of this subprogram in fe.h
1048 function First_Global
1050 Global_Mode
: Name_Id
;
1051 Refined
: Boolean := False) return Node_Id
;
1052 -- Returns the first global item of mode Global_Mode (which can be
1053 -- Name_Input, Name_Output, Name_In_Out or Name_Proof_In) associated to
1054 -- subprogram Subp, or Empty otherwise. If Refined is True, the global item
1055 -- is retrieved from the Refined_Global aspect/pragma associated to the
1056 -- body of Subp if present. Next_Global can be used to get the next global
1057 -- item with the same mode.
1059 function Fix_Msg
(Id
: Entity_Id
; Msg
: String) return String;
1060 -- Replace all occurrences of a particular word in string Msg depending on
1061 -- the Ekind of Id as follows:
1062 -- * Replace "subprogram" with
1063 -- - "entry" when Id is an entry [family]
1064 -- - "task type" when Id is a single task object, task type or task
1066 -- * Replace "protected" with
1067 -- - "task" when Id is a single task object, task type or task body
1068 -- All other non-matching words remain as is
1070 function From_Nested_Package
(T
: Entity_Id
) return Boolean;
1071 -- A type declared in a nested package may be frozen by a declaration
1072 -- appearing after the package but before the package is frozen. If the
1073 -- type has aspects that generate subprograms, these may contain references
1074 -- to entities local to the nested package. In that case the package must
1075 -- be installed on the scope stack to prevent spurious visibility errors.
1077 procedure Gather_Components
1079 Comp_List
: Node_Id
;
1080 Governed_By
: List_Id
;
1082 Report_Errors
: out Boolean;
1083 Allow_Compile_Time
: Boolean := False;
1084 Include_Interface_Tag
: Boolean := False);
1085 -- The purpose of this procedure is to gather the valid components in a
1086 -- record type according to the values of its discriminants, in order to
1087 -- validate the components of a record aggregate.
1089 -- Typ is the type of the aggregate when its constrained discriminants
1090 -- need to be collected, otherwise it is Empty.
1092 -- Comp_List is an N_Component_List node.
1094 -- Governed_By is a list of N_Component_Association nodes, where each
1095 -- choice list contains the name of a discriminant and the expression
1096 -- field gives its value. The values of the discriminants governing
1097 -- the (possibly nested) variant parts in Comp_List are found in this
1098 -- Component_Association List.
1100 -- Into is the list where the valid components are appended. Note that
1101 -- Into need not be an Empty list. If it's not, components are attached
1104 -- Report_Errors is set to True if the values of the discriminants are
1105 -- insufficiently static (see body for details of what that means).
1108 -- Allow_Compile_Time if set to True, allows compile time known values in
1109 -- Governed_By expressions in addition to static expressions.
1111 -- Include_Interface_Tag if set to True, gather any interface tag
1112 -- component, otherwise exclude them.
1114 -- This procedure is also used when building a record subtype. If the
1115 -- discriminant constraint of the subtype is static, the components of the
1116 -- subtype are only those of the variants selected by the values of the
1117 -- discriminants. Otherwise all components of the parent must be included
1118 -- in the subtype for semantic analysis.
1120 function Get_Dynamic_Accessibility
(E
: Entity_Id
) return Entity_Id
;
1121 -- Obtain the accessibility level for a given entity formal taking into
1122 -- account both extra and minimum accessibility.
1124 function Get_Actual_Subtype
(N
: Node_Id
) return Entity_Id
;
1125 -- Given a node for an expression, obtain the actual subtype of the
1126 -- expression. In the case of a parameter where the formal is an
1127 -- unconstrained array or discriminated type, this will be the previously
1128 -- constructed subtype of the actual. Note that this is not quite the
1129 -- "Actual Subtype" of the RM, since it is always a constrained type, i.e.
1130 -- it is the subtype of the value of the actual. The actual subtype is also
1131 -- returned in other cases where it has already been constructed for an
1132 -- object. Otherwise the expression type is returned unchanged, except for
1133 -- the case of an unconstrained array type, where an actual subtype is
1134 -- created, using Insert_Actions if necessary to insert any associated
1137 function Get_Actual_Subtype_If_Available
(N
: Node_Id
) return Entity_Id
;
1138 -- This is like Get_Actual_Subtype, except that it never constructs an
1139 -- actual subtype. If an actual subtype is already available, i.e. the
1140 -- Actual_Subtype field of the corresponding entity is set, then it is
1141 -- returned. Otherwise the Etype of the node is returned.
1143 function Get_Body_From_Stub
(N
: Node_Id
) return Node_Id
;
1144 -- Return the body node for a stub
1146 function Get_Cursor_Type
1148 Typ
: Entity_Id
) return Entity_Id
;
1149 -- Find Cursor type in scope of type Typ with Iterable aspect, by locating
1150 -- primitive operation First. For use in resolving the other primitive
1151 -- operations of an Iterable type and expanding loops and quantified
1152 -- expressions over formal containers.
1154 function Get_Cursor_Type
(Typ
: Entity_Id
) return Entity_Id
;
1155 -- Find Cursor type in scope of type Typ with Iterable aspect, by locating
1156 -- primitive operation First. For use after resolving the primitive
1157 -- operations of an Iterable type.
1159 function Get_Default_External_Name
(E
: Node_Or_Entity_Id
) return Node_Id
;
1160 -- This is used to construct the string literal node representing a
1161 -- default external name, i.e. one that is constructed from the name of an
1162 -- entity, or (in the case of extended DEC import/export pragmas) an
1163 -- identifier provided as the external name. Letters in the name are
1164 -- according to the setting of Opt.External_Name_Default_Casing.
1166 function Get_Enclosing_Object
(N
: Node_Id
) return Entity_Id
;
1167 -- If expression N references a part of an object, return this object.
1168 -- Otherwise return Empty. Expression N should have been resolved already.
1170 function Get_Generic_Entity
(N
: Node_Id
) return Entity_Id
;
1171 -- Returns the true generic entity in an instantiation. If the name in the
1172 -- instantiation is a renaming, the function returns the renamed generic.
1174 function Get_Incomplete_View_Of_Ancestor
(E
: Entity_Id
) return Entity_Id
;
1175 -- Implements the notion introduced ever-so briefly in RM 7.3.1 (5.2/3):
1176 -- in a child unit a derived type is within the derivation class of an
1177 -- ancestor declared in a parent unit, even if there is an intermediate
1178 -- derivation that does not see the full view of that ancestor.
1180 procedure Get_Index_Bounds
1184 Use_Full_View
: Boolean := False);
1185 -- This procedure assigns to L and H respectively the values of the low and
1186 -- high bounds of node N, which must be a range, subtype indication, or the
1187 -- name of a scalar subtype. The result in L, H may be set to Error if
1188 -- there was an earlier error in the range.
1189 -- Use_Full_View is intended for use by clients other than the compiler
1190 -- (specifically, gnat2scil) to indicate that we want the full view if
1191 -- the index type turns out to be a partial view; this case should not
1192 -- arise during normal compilation of semantically correct programs.
1194 type Range_Nodes
is record
1195 First
, Last
: Node_Id
; -- First and Last nodes of a discrete_range
1198 type Range_Values
is record
1199 First
, Last
: Uint
; -- First and Last values of a discrete_range
1202 function Get_Index_Bounds
1204 Use_Full_View
: Boolean := False) return Range_Nodes
;
1205 -- Same as the above procedure, but returns the result as a record.
1206 -- ???This should probably replace the procedure.
1208 function Get_Index_Bounds
1210 Use_Full_View
: Boolean := False) return Range_Values
;
1211 -- Same as the above function, but returns the values, which must be known
1214 procedure Get_Interfacing_Aspects
1215 (Iface_Asp
: Node_Id
;
1216 Conv_Asp
: out Node_Id
;
1217 EN_Asp
: out Node_Id
;
1218 Expo_Asp
: out Node_Id
;
1219 Imp_Asp
: out Node_Id
;
1220 LN_Asp
: out Node_Id
;
1221 Do_Checks
: Boolean := False);
1222 -- Given a single interfacing aspect Iface_Asp, retrieve other interfacing
1223 -- aspects that apply to the same related entity. The aspects considered by
1224 -- this routine are as follows:
1226 -- Conv_Asp - aspect Convention
1227 -- EN_Asp - aspect External_Name
1228 -- Expo_Asp - aspect Export
1229 -- Imp_Asp - aspect Import
1230 -- LN_Asp - aspect Link_Name
1232 -- When flag Do_Checks is set, this routine will flag duplicate uses of
1235 function Get_Enum_Lit_From_Pos
1238 Loc
: Source_Ptr
) return Node_Id
;
1239 -- This function returns an identifier denoting the E_Enumeration_Literal
1240 -- entity for the specified value from the enumeration type or subtype T.
1241 -- The second argument is the Pos value. Constraint_Error is raised if
1242 -- argument Pos is not in range. The third argument supplies a source
1243 -- location for constructed nodes returned by this function. If No_Location
1244 -- is supplied as source location, the location of the returned node is
1245 -- copied from the original source location for the enumeration literal,
1248 function Get_Iterable_Type_Primitive
1250 Nam
: Name_Id
) return Entity_Id
;
1251 -- Retrieve one of the primitives First, Last, Next, Previous, Has_Element,
1252 -- Element from the value of the Iterable aspect of a type.
1254 procedure Get_Library_Unit_Name_String
(Decl_Node
: Node_Id
);
1255 -- Retrieve the fully expanded name of the library unit declared by
1256 -- Decl_Node into the name buffer.
1258 function Get_Max_Queue_Length
(Id
: Entity_Id
) return Uint
;
1259 -- Return the argument of pragma Max_Queue_Length or zero if the annotation
1260 -- is not present. It is assumed that Id denotes an entry.
1262 function Get_Name_Entity_Id
(Id
: Name_Id
) return Entity_Id
;
1263 pragma Inline
(Get_Name_Entity_Id
);
1264 -- An entity value is associated with each name in the name table. The
1265 -- Get_Name_Entity_Id function fetches the Entity_Id of this entity, which
1266 -- is the innermost visible entity with the given name. See the body of
1267 -- Sem_Ch8 for further details on handling of entity visibility.
1269 function Get_Name_From_CTC_Pragma
(N
: Node_Id
) return String_Id
;
1270 -- Return the Name component of Test_Case pragma N
1271 -- Bad name now that this no longer applies to Contract_Case ???
1273 function Get_Parent_Entity
(Unit
: Node_Id
) return Entity_Id
;
1274 -- Get defining entity of parent unit of a child unit. In most cases this
1275 -- is the defining entity of the unit, but for a child instance whose
1276 -- parent needs a body for inlining, the instantiation node of the parent
1277 -- has not yet been rewritten as a package declaration, and the entity has
1278 -- to be retrieved from the Instance_Spec of the unit.
1280 function Get_Pragma_Id
(N
: Node_Id
) return Pragma_Id
;
1281 pragma Inline
(Get_Pragma_Id
);
1282 -- Obtains the Pragma_Id from Pragma_Name_Unmapped (N)
1284 function Get_Qualified_Name
1286 Suffix
: Entity_Id
:= Empty
) return Name_Id
;
1287 -- Obtain the fully qualified form of entity Id. The format is:
1288 -- scope_of_id-1__scope_of_id__chars_of_id__chars_of_suffix
1290 function Get_Qualified_Name
1292 Suffix
: Name_Id
:= No_Name
;
1293 Scop
: Entity_Id
:= Current_Scope
) return Name_Id
;
1294 -- Obtain the fully qualified form of name Nam assuming it appears in scope
1295 -- Scop. The format is:
1296 -- scop-1__scop__nam__suffix
1298 procedure Get_Reason_String
(N
: Node_Id
);
1299 -- Recursive routine to analyze reason argument for pragma Warnings. The
1300 -- value of the reason argument is appended to the current string using
1301 -- Store_String_Chars. The reason argument is expected to be a string
1302 -- literal or concatenation of string literals. An error is given for
1305 function Get_Reference_Discriminant
(Typ
: Entity_Id
) return Entity_Id
;
1306 -- If Typ has Implicit_Dereference, return discriminant specified in the
1307 -- corresponding aspect.
1309 function Get_Referenced_Object
(N
: Node_Id
) return Node_Id
;
1310 -- Given an arbitrary node, return the renamed object if the node
1311 -- represents a renamed object; otherwise return the node unchanged.
1312 -- The node can represent an arbitrary expression or any other kind of
1313 -- node (such as the name of a type).
1315 function Get_Renamed_Entity
(E
: Entity_Id
) return Entity_Id
;
1316 -- Given an entity for an exception, package, subprogram or generic unit,
1317 -- returns the ultimately renamed entity if this is a renaming. If this is
1318 -- not a renamed entity, returns its argument. It is an error to call this
1319 -- with any other kind of entity.
1321 function Get_Return_Object
(N
: Node_Id
) return Entity_Id
;
1322 -- Given an extended return statement, return the corresponding return
1323 -- object, identified as the one for which Is_Return_Object = True.
1325 function Get_Subprogram_Entity
(Nod
: Node_Id
) return Entity_Id
;
1326 -- Nod is either a procedure call statement, or a function call, or an
1327 -- accept statement node. This procedure finds the Entity_Id of the related
1328 -- subprogram or entry and returns it, or if no subprogram can be found,
1331 function Get_Task_Body_Procedure
(E
: Entity_Id
) return Entity_Id
;
1332 -- Given an entity for a task type or subtype, retrieves the
1333 -- Task_Body_Procedure field from the corresponding task type declaration.
1335 function Get_User_Defined_Eq
(E
: Entity_Id
) return Entity_Id
;
1336 -- For a type entity, return the entity of the primitive equality function
1337 -- for the type if it exists, otherwise return Empty.
1341 Priv_Typ
: out Entity_Id
;
1342 Full_Typ
: out Entity_Id
;
1343 UFull_Typ
: out Entity_Id
;
1344 CRec_Typ
: out Entity_Id
);
1345 -- Obtain the partial and full views of type Typ and in addition any extra
1346 -- types the full views may have. The return entities are as follows:
1348 -- Priv_Typ - the partial view (a private type)
1349 -- Full_Typ - the full view
1350 -- UFull_Typ - the underlying full view, if the full view is private
1351 -- CRec_Typ - the corresponding record type of the full views
1353 function Get_Fullest_View
1354 (E
: Entity_Id
; Include_PAT
: Boolean := True) return Entity_Id
;
1355 -- Get the fullest possible view of E, looking through private, limited,
1356 -- packed array and other implementation types. If Include_PAT is False,
1357 -- don't look inside packed array types.
1359 function Has_Access_Values
(T
: Entity_Id
) return Boolean;
1360 -- Returns true if the underlying type of T is an access type, or has a
1361 -- component (at any recursive level) that is an access type. This is a
1362 -- conservative predicate, if it is not known whether or not T contains
1363 -- access values (happens for generic formals in some cases), then False is
1364 -- returned. Note that tagged types return False. Even though the tag is
1365 -- implemented as an access type internally, this function tests only for
1366 -- access types known to the programmer. See also Has_Tagged_Component.
1368 function Has_Anonymous_Access_Discriminant
(Typ
: Entity_Id
) return Boolean;
1369 -- Returns True if Typ has one or more anonymous access discriminants
1371 type Alignment_Result
is (Known_Compatible
, Unknown
, Known_Incompatible
);
1372 -- Result of Has_Compatible_Alignment test, description found below. Note
1373 -- that the values are arranged in increasing order of problematicness.
1375 function Has_Compatible_Alignment
1378 Layout_Done
: Boolean) return Alignment_Result
;
1379 -- Obj is an object entity, and expr is a node for an object reference. If
1380 -- the alignment of the object referenced by Expr is known to be compatible
1381 -- with the alignment of Obj (i.e. is larger or the same), then the result
1382 -- is Known_Compatible. If the alignment of the object referenced by Expr
1383 -- is known to be less than the alignment of Obj, then Known_Incompatible
1384 -- is returned. If neither condition can be reliably established at compile
1385 -- time, then Unknown is returned. If Layout_Done is True, the function can
1386 -- assume that the information on size and alignment of types and objects
1387 -- is present in the tree. This is used to determine if alignment checks
1388 -- are required for address clauses (Layout_Done is False in this case) as
1389 -- well as to issue appropriate warnings for them in the post compilation
1390 -- phase (Layout_Done is True in this case).
1392 -- Note: Known_Incompatible does not mean that at run time the alignment
1393 -- of Expr is known to be wrong for Obj, just that it can be determined
1394 -- that alignments have been explicitly or implicitly specified which are
1395 -- incompatible (whereas Unknown means that even this is not known). The
1396 -- appropriate reaction of a caller to Known_Incompatible is to treat it as
1397 -- Unknown, but issue a warning that there may be an alignment error.
1399 function Has_Declarations
(N
: Node_Id
) return Boolean;
1400 -- Determines if the node can have declarations
1402 function Has_Defaulted_Discriminants
(Typ
: Entity_Id
) return Boolean;
1403 -- Simple predicate to test for defaulted discriminants
1405 function Has_Denormals
(E
: Entity_Id
) return Boolean;
1406 -- Determines if the floating-point type E supports denormal numbers.
1407 -- Returns False if E is not a floating-point type.
1409 function Has_Discriminant_Dependent_Constraint
1410 (Comp
: Entity_Id
) return Boolean;
1411 -- Returns True if and only if Comp has a constrained subtype that depends
1412 -- on a discriminant.
1414 function Has_Effectively_Volatile_Profile
1415 (Subp_Id
: Entity_Id
) return Boolean;
1416 -- Determine whether subprogram Subp_Id has an effectively volatile formal
1417 -- parameter for reading or returns an effectively volatile value for
1420 function Has_Full_Default_Initialization
(Typ
: Entity_Id
) return Boolean;
1421 -- Determine whether type Typ defines "full default initialization" as
1422 -- specified by SPARK RM 3.1. To qualify as such, the type must be
1423 -- * A scalar type with specified Default_Value
1424 -- * An array-of-scalar type with specified Default_Component_Value
1425 -- * An array type whose element type defines full default initialization
1426 -- * A protected type, record type or type extension whose components
1427 -- either include a default expression or have a type which defines
1428 -- full default initialization. In the case of type extensions, the
1429 -- parent type defines full default initialization.
1431 -- * A private type with pragma Default_Initial_Condition that provides
1432 -- full default initialization.
1433 -- This function is not used in GNATprove anymore, but is used in CodePeer.
1435 function Has_Fully_Default_Initializing_DIC_Pragma
1436 (Typ
: Entity_Id
) return Boolean;
1437 -- Determine whether type Typ has a suitable Default_Initial_Condition
1438 -- pragma which provides the full default initialization of the type.
1440 function Has_Inferable_Discriminants
(N
: Node_Id
) return Boolean;
1441 -- Ada 2005 (AI-216): A view of an Unchecked_Union object has inferable
1442 -- discriminants if it has a constrained nominal type, unless the object
1443 -- is a component of an enclosing Unchecked_Union object that is subject
1444 -- to a per-object constraint and the enclosing object lacks inferable
1447 -- An expression of an Unchecked_Union type has inferable discriminants
1448 -- if it is either a name of an object with inferable discriminants or a
1449 -- qualified expression whose subtype mark denotes a constrained subtype.
1451 function Has_Infinities
(E
: Entity_Id
) return Boolean;
1452 -- Determines if the range of the floating-point type E includes
1453 -- infinities. Returns False if E is not a floating-point type.
1455 function Has_Interfaces
1457 Use_Full_View
: Boolean := True) return Boolean;
1458 -- Where T is a concurrent type or a record type, returns true if T covers
1459 -- any abstract interface types. In case of private types the argument
1460 -- Use_Full_View controls if the check is done using its full view (if
1463 function Has_Max_Queue_Length
(Id
: Entity_Id
) return Boolean;
1464 -- Determine whether Id is subject to pragma Max_Queue_Length. It is
1465 -- assumed that Id denotes an entry.
1467 function Has_No_Obvious_Side_Effects
(N
: Node_Id
) return Boolean;
1468 -- This is a simple minded function for determining whether an expression
1469 -- has no obvious side effects. It is used only for determining whether
1470 -- warnings are needed in certain situations, and is not guaranteed to
1471 -- be accurate in either direction. Exceptions may mean an expression
1472 -- does in fact have side effects, but this may be ignored and True is
1473 -- returned, or a complex expression may in fact be side effect free
1474 -- but we don't recognize it here and return False. The Side_Effect_Free
1475 -- routine in Remove_Side_Effects is much more extensive and perhaps could
1476 -- be shared, so that this routine would be more accurate.
1478 function Has_Non_Null_Refinement
(Id
: Entity_Id
) return Boolean;
1479 -- Determine whether abstract state Id has at least one nonnull constituent
1480 -- as expressed in pragma Refined_State. This function does not take into
1481 -- account the visible refinement region of abstract state Id.
1483 function Has_Non_Trivial_Precondition
(Subp
: Entity_Id
) return Boolean;
1484 -- Determine whether subprogram Subp has a class-wide precondition that is
1485 -- not statically True.
1487 function Has_Null_Body
(Proc_Id
: Entity_Id
) return Boolean;
1488 -- Determine whether the body of procedure Proc_Id contains a sole null
1489 -- statement, possibly followed by an optional return. Used to optimize
1490 -- useless calls to assertion checks.
1492 function Has_Null_Exclusion
(N
: Node_Id
) return Boolean;
1493 -- Determine whether node N has a null exclusion
1495 function Has_Null_Refinement
(Id
: Entity_Id
) return Boolean;
1496 -- Determine whether abstract state Id has a null refinement as expressed
1497 -- in pragma Refined_State. This function does not take into account the
1498 -- visible refinement region of abstract state Id.
1500 function Has_Non_Null_Statements
(L
: List_Id
) return Boolean;
1501 -- Return True if L has non-null statements
1503 function Side_Effect_Free_Statements
(L
: List_Id
) return Boolean;
1504 -- Return True if L has no statements with side effects
1506 function Side_Effect_Free_Loop
(N
: Node_Id
) return Boolean;
1507 -- Return True if the loop has no side effect and can therefore be
1508 -- marked for removal. Return False if N is not a N_Loop_Statement.
1510 subtype Static_Accessibility_Level_Kind
1511 is Accessibility_Level_Kind
range Object_Decl_Level
1512 .. Zero_On_Dynamic_Level
;
1513 -- Restrict the reange of Accessibility_Level_Kind to be non-dynamic for
1514 -- use in the static version of Accessibility_Level below.
1516 function Static_Accessibility_Level
1518 Level
: Static_Accessibility_Level_Kind
;
1519 In_Return_Context
: Boolean := False) return Uint
;
1520 -- Overloaded version of Accessibility_Level which returns a universal
1521 -- integer for use in compile-time checking. Note: Level is restricted to
1524 function Is_Newly_Constructed
1525 (Exp
: Node_Id
; Context_Requires_NC
: Boolean) return Boolean;
1526 -- Indicates whether a given expression is "newly constructed" (RM 4.4).
1527 -- Context_Requires_NC determines the result returned for cases like a
1528 -- raise expression or a conditional expression where some-but-not-all
1529 -- operative constituents are newly constructed. Thus, this is a
1530 -- somewhat unusual predicate in that the result required in order to
1531 -- satisfy whatever legality rule is being checked can influence the
1532 -- result of the predicate. Context_Requires_NC might be True for
1533 -- something like the "newly constructed" rule for a limited expression
1534 -- of a return statement, and False for something like the
1535 -- "newly constructed" rule pertaining to a limited object renaming in a
1536 -- declare expression. Eventually, the code to implement every
1537 -- RM legality rule requiring/prohibiting a "newly constructed" expression
1538 -- should be implemented by calling this function; that's not done yet.
1539 -- The function name doesn't quite match the RM definition of the term if
1540 -- Context_Requires_NC = False; in that case, "Might_Be_Newly_Constructed"
1541 -- might be a more accurate name.
1543 function Is_Prim_Of_Abst_Type_With_Nonstatic_CW_Pre_Post
1544 (Subp
: Entity_Id
) return Boolean;
1545 -- Return True if Subp is a primitive of an abstract type, where the
1546 -- primitive has a class-wide pre- or postcondition whose expression
1549 function Has_Overriding_Initialize
(T
: Entity_Id
) return Boolean;
1550 -- Predicate to determine whether a controlled type has a user-defined
1551 -- Initialize primitive (and, in Ada 2012, whether that primitive is
1552 -- non-null), which causes the type to not have preelaborable
1555 function Has_Preelaborable_Initialization
1557 Preelab_Init_Expr
: Node_Id
:= Empty
) return Boolean;
1558 -- Return True iff type E has preelaborable initialization as defined in
1559 -- Ada 2005 (see AI-161 for details of the definition of this attribute).
1560 -- If Preelab_Init_Expr is present, indicates that the function should
1561 -- presume that for any subcomponent of E that is of a formal private or
1562 -- derived type that is referenced by a Preelaborable_Initialization
1563 -- attribute within the expression Preelab_Init_Expr, the formal type has
1564 -- preelaborable initialization (RM 10.2.1(11.8/5) and AI12-0409).
1566 function Has_Prefix
(N
: Node_Id
) return Boolean;
1567 -- Return True if N has attribute Prefix
1569 function Has_Private_Component
(Type_Id
: Entity_Id
) return Boolean;
1570 -- Check if a type has a (sub)component of a private type that has not
1571 -- yet received a full declaration.
1573 function Has_Relaxed_Initialization
(E
: Entity_Id
) return Boolean;
1574 -- Returns True iff entity E is subject to the Relaxed_Initialization
1575 -- aspect. Entity E can be either type, variable, constant, subprogram,
1576 -- entry or an abstract state. For private types and deferred constants
1577 -- E should be the private view, because aspect can only be attached there.
1579 function Has_Signed_Zeros
(E
: Entity_Id
) return Boolean;
1580 -- Determines if the floating-point type E supports signed zeros.
1581 -- Returns False if E is not a floating-point type.
1583 function Has_Significant_Contract
(Subp_Id
: Entity_Id
) return Boolean;
1584 -- Determine whether subprogram [body] Subp_Id has a significant contract.
1585 -- All subprograms have a N_Contract node, but this does not mean that the
1586 -- contract is useful.
1588 function Has_Static_Array_Bounds
(Typ
: Node_Id
) return Boolean;
1589 -- Return whether an array type has static bounds
1591 function Has_Static_Non_Empty_Array_Bounds
(Typ
: Node_Id
) return Boolean;
1592 -- Determine whether array type Typ has static non-empty bounds
1594 function Has_Stream
(T
: Entity_Id
) return Boolean;
1595 -- Tests if type T is derived from Ada.Streams.Root_Stream_Type, or in the
1596 -- case of a composite type, has a component for which this predicate is
1597 -- True, and if so returns True. Otherwise a result of False means that
1598 -- there is no Stream type in sight. For a private type, the test is
1599 -- applied to the underlying type (or returns False if there is no
1600 -- underlying type).
1602 function Has_Suffix
(E
: Entity_Id
; Suffix
: Character) return Boolean;
1603 -- Returns true if the last character of E is Suffix. Used in Assertions.
1605 function Has_Tagged_Component
(Typ
: Entity_Id
) return Boolean;
1606 -- Returns True if Typ is a composite type (array or record) that is either
1607 -- a tagged type or has a subcomponent that is tagged. Returns False for a
1608 -- noncomposite type, or if no tagged subcomponents are present.
1610 function Has_Unconstrained_Access_Discriminants
1611 (Subtyp
: Entity_Id
) return Boolean;
1612 -- Returns True if the given subtype is unconstrained and has one or more
1613 -- access discriminants.
1615 function Has_Undefined_Reference
(Expr
: Node_Id
) return Boolean;
1616 -- Given arbitrary expression Expr, determine whether it contains at
1617 -- least one name whose entity is Any_Id.
1619 function Has_Volatile_Component
(Typ
: Entity_Id
) return Boolean;
1620 -- Given arbitrary type Typ, determine whether it contains at least one
1621 -- volatile component.
1623 function Implementation_Kind
(Subp
: Entity_Id
) return Name_Id
;
1624 -- Subp is a subprogram marked with pragma Implemented. Return the specific
1625 -- implementation requirement which the pragma imposes. The return value is
1626 -- either Name_By_Any, Name_By_Entry or Name_By_Protected_Procedure.
1628 function Implements_Interface
1629 (Typ_Ent
: Entity_Id
;
1630 Iface_Ent
: Entity_Id
;
1631 Exclude_Parents
: Boolean := False) return Boolean;
1632 -- Returns true if the Typ_Ent implements interface Iface_Ent
1634 function Implicitly_Designated_Type
(Typ
: Entity_Id
) return Entity_Id
;
1635 -- Called when Typ is the type of the prefix of an implicit dereference.
1636 -- Return the designated type of Typ, taking into account that this type
1637 -- may be a limited view, when the nonlimited view is visible.
1639 function In_Assertion_Expression_Pragma
(N
: Node_Id
) return Boolean;
1640 -- Returns True if node N appears within a pragma that acts as an assertion
1641 -- expression. See Sem_Prag for the list of qualifying pragmas.
1643 function In_Check_Node
(N
: Node_Id
) return Boolean;
1644 -- Return True if N is part of a N_Raise_xxx_Error node
1646 function In_Generic_Formal_Package
(E
: Entity_Id
) return Boolean;
1647 -- Returns True if entity E is inside a generic formal package
1649 function In_Generic_Scope
(E
: Entity_Id
) return Boolean;
1650 -- Returns True if entity E is inside a generic scope
1652 function In_Instance
return Boolean;
1653 -- Returns True if the current scope is within a generic instance
1655 function In_Instance_Body
return Boolean;
1656 -- Returns True if current scope is within the body of an instance, where
1657 -- several semantic checks (e.g. accessibility checks) are relaxed.
1659 function In_Instance_Not_Visible
return Boolean;
1660 -- Returns True if current scope is with the private part or the body of
1661 -- an instance. Other semantic checks are suppressed in this context.
1663 function In_Instance_Visible_Part
1664 (Id
: Entity_Id
:= Current_Scope
) return Boolean;
1665 -- Returns True if arbitrary entity Id is within the visible part of a
1666 -- package instance, where several additional semantic checks apply.
1668 function In_Package_Body
return Boolean;
1669 -- Returns True if current scope is within a package body
1671 function In_Pragma_Expression
(N
: Node_Id
; Nam
: Name_Id
) return Boolean;
1672 -- Returns true if the expression N occurs within a pragma with name Nam
1674 function In_Pre_Post_Condition
1675 (N
: Node_Id
; Class_Wide_Only
: Boolean := False) return Boolean;
1676 -- Returns True if node N appears within a pre/postcondition pragma. Note
1677 -- the pragma Check equivalents are NOT considered. If Class_Wide_Only is
1678 -- True, then tests for N appearing within a class-wide pre/postcondition.
1680 function In_Quantified_Expression
(N
: Node_Id
) return Boolean;
1681 -- Returns true if the expression N occurs within a quantified expression
1683 function In_Return_Value
(Expr
: Node_Id
) return Boolean;
1684 -- Returns true if the expression Expr occurs within a simple return
1685 -- statement or is part of an assignment to the return object in an
1686 -- extended return statement.
1688 function In_Reverse_Storage_Order_Object
(N
: Node_Id
) return Boolean;
1689 -- Returns True if N denotes a component or subcomponent in a record or
1690 -- array that has Reverse_Storage_Order.
1692 function In_Same_Declarative_Part
1694 N
: Node_Id
) return Boolean;
1695 -- True if the node N appears within the same declarative part denoted by
1696 -- the node Context.
1698 function In_Subprogram_Or_Concurrent_Unit
return Boolean;
1699 -- Determines if the current scope is within a subprogram compilation unit
1700 -- (inside a subprogram declaration, subprogram body, or generic subprogram
1701 -- declaration) or within a task or protected body. The test is for
1702 -- appearing anywhere within such a construct (that is it does not need
1703 -- to be directly within).
1705 function In_Subtree
(N
: Node_Id
; Root
: Node_Id
) return Boolean;
1706 -- Determine whether node N is within the subtree rooted at Root
1711 Root2
: Node_Id
) return Boolean;
1712 -- Determine whether node N is within the subtree rooted at Root1 or Root2.
1713 -- This version is more efficient than calling the single root version of
1714 -- Is_Subtree twice.
1716 function In_Visible_Part
(Scope_Id
: Entity_Id
) return Boolean;
1717 -- Determine whether a declaration occurs within the visible part of a
1718 -- package specification. The package must be on the scope stack, and the
1719 -- corresponding private part must not.
1721 function In_While_Loop_Condition
(N
: Node_Id
) return Boolean;
1722 -- Returns true if the expression N occurs within the condition of a while
1724 function Incomplete_Or_Partial_View
(Id
: Entity_Id
) return Entity_Id
;
1725 -- Given the entity of a constant or a type, retrieve the incomplete or
1726 -- partial view of the same entity. Note that Id may not have a partial
1727 -- view in which case the function returns Empty.
1729 function Incomplete_View_From_Limited_With
1730 (Typ
: Entity_Id
) return Entity_Id
;
1731 -- Typ is a type entity. This normally returns Typ. However, if there is
1732 -- an incomplete view of this entity that comes from a limited-with'ed
1733 -- package, then this returns that incomplete view.
1735 function Indexed_Component_Bit_Offset
(N
: Node_Id
) return Uint
;
1736 -- Given an N_Indexed_Component node, return the first bit position of the
1737 -- component if it is known at compile time. A value of No_Uint means that
1738 -- either the value is not yet known before back-end processing or it is
1739 -- not known at compile time after back-end processing.
1741 procedure Inherit_Predicate_Flags
(Subt
, Par
: Entity_Id
);
1742 -- Propagate static and dynamic predicate flags from a parent to the
1743 -- subtype in a subtype declaration with and without constraints.
1745 procedure Inherit_Rep_Item_Chain
(Typ
: Entity_Id
; From_Typ
: Entity_Id
);
1746 -- Inherit the rep item chain of type From_Typ without clobbering any
1747 -- existing rep items on Typ's chain. Typ is the destination type.
1749 function Inherits_From_Tagged_Full_View
(Typ
: Entity_Id
) return Boolean;
1750 pragma Inline
(Inherits_From_Tagged_Full_View
);
1751 -- Return True if Typ is an untagged private type completed with a
1752 -- derivation of an untagged private type declaration whose full view
1753 -- is a tagged type.
1755 procedure Insert_Explicit_Dereference
(N
: Node_Id
);
1756 -- In a context that requires a composite or subprogram type and where a
1757 -- prefix is an access type, rewrite the access type node N (which is the
1758 -- prefix, e.g. of an indexed component) as an explicit dereference.
1760 procedure Inspect_Deferred_Constant_Completion
(Decls
: List_Id
);
1761 -- Examine all deferred constants in the declaration list Decls and check
1762 -- whether they have been completed by a full constant declaration or an
1763 -- Import pragma. Emit the error message if that is not the case.
1765 procedure Install_Elaboration_Model
(Unit_Id
: Entity_Id
);
1766 -- Install the elaboration model specified by pragma Elaboration_Checks
1767 -- associated with compilation unit Unit_Id. No action is taken when the
1768 -- unit lacks such pragma.
1770 procedure Install_Generic_Formals
(Subp_Id
: Entity_Id
);
1771 -- Install both the generic formal parameters and the formal parameters of
1772 -- generic subprogram Subp_Id into visibility.
1774 procedure Install_SPARK_Mode
(Mode
: SPARK_Mode_Type
; Prag
: Node_Id
);
1775 -- Establish the SPARK_Mode and SPARK_Mode_Pragma currently in effect
1777 function Invalid_Scalar_Value
1779 Scal_Typ
: Scalar_Id
) return Node_Id
;
1780 -- Obtain the invalid value for scalar type Scal_Typ as either specified by
1781 -- pragma Initialize_Scalars or by the binder. Return an expression created
1782 -- at source location Loc, which denotes the invalid value.
1784 function Is_Anonymous_Access_Actual
(N
: Node_Id
) return Boolean;
1785 -- Determine if N is used as an actual for a call whose corresponding
1786 -- formal is of an anonymous access type.
1788 function Is_Access_Subprogram_Wrapper
(E
: Entity_Id
) return Boolean;
1789 -- True if E is the constructed wrapper for an access_to_subprogram
1790 -- type with Pre/Postconditions.
1792 function Is_Access_Variable
(E
: Entity_Id
) return Boolean;
1793 -- Determines if type E is an access-to-variable
1795 function Is_Actual_In_Out_Parameter
(N
: Node_Id
) return Boolean;
1796 -- Determines if N is an actual parameter of in-out mode in a subprogram
1799 function Is_Actual_Out_Parameter
(N
: Node_Id
) return Boolean;
1800 -- Determines if N is an actual parameter of out mode in a subprogram call
1802 function Is_Actual_Out_Or_In_Out_Parameter
(N
: Node_Id
) return Boolean;
1803 -- Determines if N is an actual parameter of out or in out mode in a
1806 function Is_Actual_Parameter
(N
: Node_Id
) return Boolean;
1807 -- Determines if N is an actual parameter in a subprogram or entry call
1809 function Is_Actual_Tagged_Parameter
(N
: Node_Id
) return Boolean;
1810 -- Determines if N is an actual parameter of a formal of tagged type in a
1813 function Is_Aliased_View
(Obj
: Node_Id
) return Boolean;
1814 -- Determine if Obj is an aliased view, i.e. the name of an object to which
1815 -- 'Access or 'Unchecked_Access can apply. Note that this routine uses the
1816 -- rules of the language, it does not take into account the restriction
1817 -- No_Implicit_Aliasing, so it can return True if the restriction is active
1818 -- and Obj violates the restriction. The caller is responsible for calling
1819 -- Restrict.Check_No_Implicit_Aliasing if True is returned, but there is a
1820 -- requirement for obeying the restriction in the call context.
1822 function Is_Ancestor_Package
1824 E2
: Entity_Id
) return Boolean;
1825 -- Determine whether package E1 is an ancestor of E2
1827 function Is_Atomic_Object
(N
: Node_Id
) return Boolean;
1828 -- Determine whether arbitrary node N denotes a reference to an atomic
1829 -- object as per RM C.6(7) and the crucial remark in RM C.6(8).
1831 function Is_Attribute_Loop_Entry
(N
: Node_Id
) return Boolean;
1832 -- Determine whether node N denotes attribute 'Loop_Entry
1834 function Is_Attribute_Old
(N
: Node_Id
) return Boolean;
1835 -- Determine whether node N denotes attribute 'Old
1837 function Is_Attribute_Result
(N
: Node_Id
) return Boolean;
1838 -- Determine whether node N denotes attribute 'Result
1840 function Is_Attribute_Update
(N
: Node_Id
) return Boolean;
1841 -- Determine whether node N denotes attribute 'Update
1843 function Is_Body_Or_Package_Declaration
(N
: Node_Id
) return Boolean;
1844 -- Determine whether node N denotes a body or a package declaration
1846 function Is_Bounded_String
(T
: Entity_Id
) return Boolean;
1847 -- True if T is a bounded string type. Used to make sure "=" composes
1848 -- properly for bounded string types.
1850 function Is_By_Protected_Procedure
(Id
: Entity_Id
) return Boolean;
1851 -- Determine whether entity Id denotes a procedure with synchronization
1852 -- kind By_Protected_Procedure.
1854 function Is_Confirming
(Aspect
: Nonoverridable_Aspect_Id
;
1855 Aspect_Spec_1
, Aspect_Spec_2
: Node_Id
)
1857 -- Returns true if the two specifications of the given
1858 -- nonoverridable aspect are compatible.
1860 function Is_Conjunction_Of_Formal_Preelab_Init_Attributes
1861 (Expr
: Node_Id
) return Boolean;
1862 -- Returns True if Expr is a Preelaborable_Initialization attribute applied
1863 -- to a formal type, or a sequence of two or more such attributes connected
1864 -- by "and" operators, or if the Original_Node of Expr or its constituents
1865 -- is such an attribute.
1867 function Is_Constant_Bound
(Exp
: Node_Id
) return Boolean;
1868 -- Exp is the expression for an array bound. Determines whether the
1869 -- bound is a compile-time known value, or a constant entity, or an
1870 -- enumeration literal, or an expression composed of constant-bound
1871 -- subexpressions which are evaluated by means of standard operators.
1873 function Is_Container_Element
(Exp
: Node_Id
) return Boolean;
1874 -- This routine recognizes expressions that denote an element of one of
1875 -- the predefined containers, when the source only contains an indexing
1876 -- operation and an implicit dereference is inserted by the compiler.
1877 -- In the absence of this optimization, the indexing creates a temporary
1878 -- controlled cursor that sets the tampering bit of the container, and
1879 -- restricts the use of the convenient notation C (X) to contexts that
1880 -- do not check the tampering bit (e.g. C.Include (X, C (Y)). Exp is an
1881 -- explicit dereference. The transformation applies when it has the form
1884 function Is_Contract_Annotation
(Item
: Node_Id
) return Boolean;
1885 -- Determine whether aspect specification or pragma Item is a contract
1888 function Is_Controlling_Limited_Procedure
1889 (Proc_Nam
: Entity_Id
) return Boolean;
1890 -- Ada 2005 (AI-345): Determine whether Proc_Nam is a primitive procedure
1891 -- of a limited interface with a controlling first parameter.
1893 function Is_CPP_Constructor_Call
(N
: Node_Id
) return Boolean;
1894 -- Returns True if N is a call to a CPP constructor
1896 function Is_CCT_Instance
1897 (Ref_Id
: Entity_Id
;
1898 Context_Id
: Entity_Id
) return Boolean;
1899 -- Subsidiary to the analysis of pragmas [Refined_]Depends and [Refined_]
1900 -- Global; also used when analyzing default expressions of protected and
1901 -- record components. Determine whether entity Ref_Id (which must represent
1902 -- either a protected type or a task type) denotes the current instance of
1903 -- a concurrent type. Context_Id denotes the associated context where the
1906 function Is_Child_Or_Sibling
1907 (Pack_1
: Entity_Id
;
1908 Pack_2
: Entity_Id
) return Boolean;
1909 -- Determine the following relations between two arbitrary packages:
1910 -- 1) One package is the parent of a child package
1911 -- 2) Both packages are siblings and share a common parent
1913 function Is_Concurrent_Interface
(T
: Entity_Id
) return Boolean;
1914 -- First determine whether type T is an interface and then check whether
1915 -- it is of protected, synchronized or task kind.
1917 function Is_Current_Instance
(N
: Node_Id
) return Boolean;
1918 -- Predicate is true if N legally denotes a type name within its own
1919 -- declaration. Prior to Ada 2012 this covered only synchronized type
1920 -- declarations. In Ada 2012 it also covers type and subtype declarations
1921 -- with aspects: Invariant, Predicate, and Default_Initial_Condition.
1923 function Is_Current_Instance_Reference_In_Type_Aspect
1924 (N
: Node_Id
) return Boolean;
1925 -- True if N is a reference to a current instance object that occurs within
1926 -- an aspect_specification for a type or subtype. In this case N will be
1927 -- a formal parameter of a subprogram created for a predicate, invariant,
1928 -- or Default_Initial_Condition aspect.
1930 function Is_Declaration
1932 Body_OK
: Boolean := True;
1933 Concurrent_OK
: Boolean := True;
1934 Formal_OK
: Boolean := True;
1935 Generic_OK
: Boolean := True;
1936 Instantiation_OK
: Boolean := True;
1937 Renaming_OK
: Boolean := True;
1938 Stub_OK
: Boolean := True;
1939 Subprogram_OK
: Boolean := True;
1940 Type_OK
: Boolean := True) return Boolean;
1941 -- Determine whether arbitrary node N denotes a declaration depending
1942 -- on the allowed subsets of declarations. Set the following flags to
1943 -- consider specific subsets of declarations:
1945 -- * Body_OK - body declarations
1947 -- * Concurrent_OK - concurrent type declarations
1949 -- * Formal_OK - formal declarations
1951 -- * Generic_OK - generic declarations, including generic renamings
1953 -- * Instantiation_OK - generic instantiations
1955 -- * Renaming_OK - renaming declarations, including generic renamings
1957 -- * Stub_OK - stub declarations
1959 -- * Subprogram_OK - entry, expression function, and subprogram
1962 -- * Type_OK - type declarations, including concurrent types
1964 function Is_Declared_Within_Variant
(Comp
: Entity_Id
) return Boolean;
1965 -- Returns True iff component Comp is declared within a variant part
1967 function Is_Dependent_Component_Of_Mutable_Object
1968 (Object
: Node_Id
) return Boolean;
1969 -- Returns True if Object is the name of a subcomponent that depends on
1970 -- discriminants of a variable whose nominal subtype is unconstrained and
1971 -- not indefinite, and the variable is not aliased. Otherwise returns
1972 -- False. The nodes passed to this function are assumed to denote objects.
1974 function Is_Dereferenced
(N
: Node_Id
) return Boolean;
1975 -- N is a subexpression node of an access type. This function returns true
1976 -- if N appears as the prefix of a node that does a dereference of the
1977 -- access value (selected/indexed component, explicit dereference or a
1978 -- slice), and false otherwise.
1980 function Is_Descendant_Of
(T1
: Entity_Id
; T2
: Entity_Id
) return Boolean;
1981 -- Returns True if type T1 is a descendant of type T2, and false otherwise.
1982 -- This is the RM definition, a type is a descendant of another type if it
1983 -- is the same type or is derived from a descendant of the other type.
1985 function Is_Descendant_Of_Suspension_Object
1986 (Typ
: Entity_Id
) return Boolean;
1987 -- Determine whether type Typ is a descendant of type Suspension_Object
1988 -- defined in Ada.Synchronous_Task_Control. This version is different from
1989 -- Is_Descendant_Of as the detection of Suspension_Object does not involve
1990 -- an entity and by extension a call to RTSfind.
1992 function Is_Double_Precision_Floating_Point_Type
1993 (E
: Entity_Id
) return Boolean;
1994 -- Return whether E is a double precision floating point type,
1995 -- characterized by:
1996 -- . machine_radix = 2
1997 -- . machine_mantissa = 53
1998 -- . machine_emax = 2**10
1999 -- . machine_emin = 3 - machine_emax
2001 function Is_Effectively_Volatile
2003 Ignore_Protected
: Boolean := False) return Boolean;
2004 -- Determine whether a type or object denoted by entity Id is effectively
2005 -- volatile (SPARK RM 7.1.2). To qualify as such, the entity must be either
2006 -- * Volatile without No_Caching
2007 -- * An array type subject to aspect Volatile_Components
2008 -- * An array type whose component type is effectively volatile
2009 -- * A protected type
2010 -- * Descendant of type Ada.Synchronous_Task_Control.Suspension_Object
2012 -- If Ignore_Protected is True, then a protected object/type is treated
2013 -- like a non-protected record object/type for computing the result of
2016 function Is_Effectively_Volatile_For_Reading
2018 Ignore_Protected
: Boolean := False) return Boolean;
2019 -- Determine whether a type or object denoted by entity Id is effectively
2020 -- volatile for reading (SPARK RM 7.1.2). To qualify as such, the entity
2022 -- * Volatile without No_Caching and have Async_Writers or
2023 -- Effective_Reads set to True
2024 -- * An array type subject to aspect Volatile_Components, unless it has
2025 -- Async_Writers and Effective_Reads set to False
2026 -- * An array type whose component type is effectively volatile for
2028 -- * A protected type
2029 -- * Descendant of type Ada.Synchronous_Task_Control.Suspension_Object
2031 -- If Ignore_Protected is True, then a protected object/type is treated
2032 -- like a non-protected record object/type for computing the result of
2035 function Is_Effectively_Volatile_Object
2036 (N
: Node_Id
) return Boolean;
2037 -- Determine whether an arbitrary node denotes an effectively volatile
2038 -- object (SPARK RM 7.1.2).
2040 function Is_Effectively_Volatile_Object_For_Reading
2041 (N
: Node_Id
) return Boolean;
2042 -- Determine whether an arbitrary node denotes an effectively volatile
2043 -- object for reading (SPARK RM 7.1.2).
2045 function Is_Entry_Body
(Id
: Entity_Id
) return Boolean;
2046 -- Determine whether entity Id is the body entity of an entry [family]
2048 function Is_Entry_Declaration
(Id
: Entity_Id
) return Boolean;
2049 -- Determine whether entity Id is the spec entity of an entry [family]
2051 function Is_Explicitly_Aliased
(N
: Node_Id
) return Boolean;
2052 -- Determine if a given node N is an explicitly aliased formal parameter.
2054 function Is_Expanded_Priority_Attribute
(E
: Entity_Id
) return Boolean;
2055 -- Check whether a function in a call is an expanded priority attribute,
2056 -- which is transformed into an Rtsfind call to Get_Ceiling. This expansion
2057 -- does not take place in a configurable runtime.
2059 function Is_Expression_Function
(Subp
: Entity_Id
) return Boolean;
2060 -- Determine whether subprogram [body] Subp denotes an expression function
2062 function Is_Expression_Function_Or_Completion
2063 (Subp
: Entity_Id
) return Boolean;
2064 -- Determine whether subprogram [body] Subp denotes an expression function
2065 -- or is completed by an expression function body.
2067 function Is_Extended_Precision_Floating_Point_Type
2068 (E
: Entity_Id
) return Boolean;
2069 -- Return whether E is an extended precision floating point type,
2070 -- characterized by:
2071 -- . machine_radix = 2
2072 -- . machine_mantissa = 64
2073 -- . machine_emax = 2**14
2074 -- . machine_emin = 3 - machine_emax
2076 function Is_EVF_Expression
(N
: Node_Id
) return Boolean;
2077 -- Determine whether node N denotes a reference to a formal parameter of
2078 -- a specific tagged type whose related subprogram is subject to pragma
2079 -- Extensions_Visible with value "False" (SPARK RM 6.1.7). Several other
2080 -- constructs fall under this category:
2081 -- 1) A qualified expression whose operand is EVF
2082 -- 2) A type conversion whose operand is EVF
2083 -- 3) An if expression with at least one EVF dependent_expression
2084 -- 4) A case expression with at least one EVF dependent_expression
2086 function Is_False
(U
: Opt_Ubool
) return Boolean;
2087 pragma Inline
(Is_False
);
2088 -- True if U is Boolean'Pos (False) (i.e. Uint_0)
2090 function Is_True
(U
: Opt_Ubool
) return Boolean;
2091 pragma Inline
(Is_True
);
2092 -- True if U is Boolean'Pos (True) (i.e. Uint_1). Also True if U is
2093 -- No_Uint; we allow No_Uint because Static_Boolean returns that in
2094 -- case of error. It doesn't really matter whether the error case is
2095 -- considered True or False, but we don't want this to blow up in that
2098 function Is_Fixed_Model_Number
(U
: Ureal
; T
: Entity_Id
) return Boolean;
2099 -- Returns True iff the number U is a model number of the fixed-point type
2100 -- T, i.e. if it is an exact multiple of Small.
2102 function Is_Full_Access_Object
(N
: Node_Id
) return Boolean;
2103 -- Determine whether arbitrary node N denotes a reference to a full access
2104 -- object as per Ada 2022 RM C.6(8.2).
2106 function Is_Fully_Initialized_Type
(Typ
: Entity_Id
) return Boolean;
2107 -- Typ is a type entity. This function returns true if this type is fully
2108 -- initialized, meaning that an object of the type is fully initialized.
2109 -- Note that initialization resulting from use of pragma Normalize_Scalars
2110 -- does not count. Note that this is only used for the purpose of issuing
2111 -- warnings for objects that are potentially referenced uninitialized. This
2112 -- means that the result returned is not crucial, but should err on the
2113 -- side of thinking things are fully initialized if it does not know.
2115 function Is_Generic_Declaration_Or_Body
(Decl
: Node_Id
) return Boolean;
2116 -- Determine whether arbitrary declaration Decl denotes a generic package,
2117 -- a generic subprogram or a generic body.
2119 function Is_Independent_Object
(N
: Node_Id
) return Boolean;
2120 -- Determine whether arbitrary node N denotes a reference to an independent
2121 -- object as per RM C.6(8).
2123 function Is_Inherited_Operation
(E
: Entity_Id
) return Boolean;
2124 -- E is a subprogram. Return True is E is an implicit operation inherited
2125 -- by a derived type declaration.
2127 function Is_Inherited_Operation_For_Type
2129 Typ
: Entity_Id
) return Boolean;
2130 -- E is a subprogram. Return True is E is an implicit operation inherited
2131 -- by the derived type declaration for type Typ.
2133 function Is_Inlinable_Expression_Function
(Subp
: Entity_Id
) return Boolean;
2134 -- Return True if Subp is an expression function that fulfills all the
2135 -- following requirements for inlining:
2136 -- 1. pragma/aspect Inline_Always
2139 -- 4. No dispatching primitive
2140 -- 5. Result subtype controlled (or with controlled components)
2141 -- 6. Result subtype not subject to type-invariant checks
2142 -- 7. Result subtype not a class-wide type
2143 -- 8. Return expression naming an object global to the function
2144 -- 9. Nominal subtype of the returned object statically compatible
2145 -- with the result subtype of the expression function.
2147 function Is_Iterator
(Typ
: Entity_Id
) return Boolean;
2148 -- AI05-0139-2: Check whether Typ is one of the predefined interfaces in
2149 -- Ada.Iterator_Interfaces, or it is derived from one.
2151 function Is_Iterator_Over_Array
(N
: Node_Id
) return Boolean;
2152 -- N is an iterator specification. Returns True iff N is an iterator over
2153 -- an array, either inside a loop of the form 'for X of A' or a quantified
2154 -- expression of the form 'for all/some X of A' where A is of array type.
2156 type Is_LHS_Result
is (Yes
, No
, Unknown
);
2157 function Is_LHS
(N
: Node_Id
) return Is_LHS_Result
;
2158 -- Returns Yes if N is definitely used as Name in an assignment statement.
2159 -- Returns No if N is definitely NOT used as a Name in an assignment
2160 -- statement. Returns Unknown if we can't tell at this stage (happens in
2161 -- the case where we don't know the type of N yet, and we have something
2162 -- like N.A := 3, where this counts as N being used on the left side of
2163 -- an assignment only if N is not an access type. If it is an access type
2164 -- then it is N.all.A that is assigned, not N.
2166 function Is_Library_Level_Entity
(E
: Entity_Id
) return Boolean;
2167 -- A library-level declaration is one that is accessible from Standard,
2168 -- i.e. a library unit or an entity declared in a library package.
2170 function Is_Limited_Class_Wide_Type
(Typ
: Entity_Id
) return Boolean;
2171 -- Determine whether a given type is a limited class-wide type, in which
2172 -- case it needs a Master_Id, because extensions of its designated type
2173 -- may include task components. A class-wide type that comes from a
2174 -- limited view must be treated in the same way.
2176 function Is_Local_Variable_Reference
(Expr
: Node_Id
) return Boolean;
2177 -- Determines whether Expr is a reference to a variable or formal parameter
2178 -- of mode OUT or IN OUT of the current enclosing subprogram.
2180 function Is_Master
(N
: Node_Id
) return Boolean;
2181 -- Determine if the given node N constitutes a finalization master
2183 function Is_Name_Reference
(N
: Node_Id
) return Boolean;
2184 -- Determine whether arbitrary node N is a reference to a name. This is
2185 -- similar to Is_Object_Reference but returns True only if N can be renamed
2186 -- without the need for a temporary, the typical example of an object not
2187 -- in this category being a function call.
2189 function Is_Non_Preelaborable_Construct
(N
: Node_Id
) return Boolean;
2190 -- Determine whether arbitrary construct N violates preelaborability as
2191 -- defined in ARM 10.2.1 5-9/3. This routine takes into account both the
2192 -- syntactic and semantic properties of the construct.
2194 function Is_Nontrivial_DIC_Procedure
(Id
: Entity_Id
) return Boolean;
2195 -- Determine whether entity Id denotes the procedure that verifies the
2196 -- assertion expression of pragma Default_Initial_Condition and if it does,
2197 -- the encapsulated expression is nontrivial.
2199 function Is_Null_Extension
2200 (T
: Entity_Id
; Ignore_Privacy
: Boolean := False) return Boolean;
2201 -- Given a tagged type, returns True if argument is a type extension
2202 -- that introduces no new components (discriminant or nondiscriminant).
2203 -- Ignore_Privacy should be True for use in implementing dynamic semantics.
2205 function Is_Null_Extension_Of
2206 (Descendant
, Ancestor
: Entity_Id
) return Boolean;
2207 -- Given two tagged types, the first a descendant of the second,
2208 -- returns True if every component of Descendant is inherited
2209 -- (directly or indirectly) from Ancestor. Privacy is ignored.
2211 function Is_Null_Record_Definition
(Record_Def
: Node_Id
) return Boolean;
2212 -- Returns True for an N_Record_Definition node that has no user-defined
2213 -- components (and no variant part).
2215 function Is_Null_Record_Type
2216 (T
: Entity_Id
; Ignore_Privacy
: Boolean := False) return Boolean;
2217 -- Determine whether T is declared with a null record definition, a
2218 -- null component list, or as a type derived from a null record type
2219 -- (with a null extension if tagged). Returns True for interface types,
2220 -- False for discriminated types.
2222 function Is_Object_Image
(Prefix
: Node_Id
) return Boolean;
2223 -- Returns True if an 'Img, 'Image, 'Wide_Image, or 'Wide_Wide_Image
2224 -- attribute is applied to an object.
2226 function Is_Object_Reference
(N
: Node_Id
) return Boolean;
2227 -- Determines if the tree referenced by N represents an object. Both
2228 -- variable and constant objects return True (compare Is_Variable).
2230 function Is_OK_Variable_For_Out_Formal
(AV
: Node_Id
) return Boolean;
2231 -- Used to test if AV is an acceptable formal for an OUT or IN OUT formal.
2232 -- Note that the Is_Variable function is not quite the right test because
2233 -- this is a case in which conversions whose expression is a variable (in
2234 -- the Is_Variable sense) with an untagged type target are considered view
2235 -- conversions and hence variables.
2237 function Is_OK_Volatile_Context
2240 Check_Actuals
: Boolean) return Boolean;
2241 -- Determine whether node Context denotes a "non-interfering context" (as
2242 -- defined in SPARK RM 7.1.3(10)) where volatile reference Obj_Ref can
2243 -- safely reside. When examining references that might be located within
2244 -- actual parameters of a subprogram call that has not been resolved yet,
2245 -- Check_Actuals should be False; such references will be assumed to be
2246 -- legal. They will need to be checked again after subprogram call has
2249 function Is_Package_Contract_Annotation
(Item
: Node_Id
) return Boolean;
2250 -- Determine whether aspect specification or pragma Item is one of the
2251 -- following package contract annotations:
2253 -- Initial_Condition
2257 function Is_Partially_Initialized_Type
2259 Include_Implicit
: Boolean := True) return Boolean;
2260 -- Typ is a type entity. This function returns true if this type is partly
2261 -- initialized, meaning that an object of the type is at least partly
2262 -- initialized (in particular in the record case, that at least one
2263 -- component has an initialization expression, including via Default_Value
2264 -- and Default_Component_Value aspects). Note that initialization
2265 -- resulting from the use of pragma Normalize_Scalars does not count.
2266 -- Include_Implicit controls whether implicit initialization of access
2267 -- values to null, and of discriminant values, is counted as making the
2268 -- type be partially initialized. For the default setting of True, these
2269 -- implicit cases do count, and discriminated types or types containing
2270 -- access values not explicitly initialized will return True. Otherwise
2271 -- if Include_Implicit is False, these cases do not count as making the
2272 -- type be partially initialized.
2274 function Is_Potentially_Unevaluated
(N
: Node_Id
) return Boolean;
2275 -- Predicate to implement definition given in RM 6.1.1 (20/3)
2277 function Is_Potentially_Persistent_Type
(T
: Entity_Id
) return Boolean;
2278 -- Determines if type T is a potentially persistent type. A potentially
2279 -- persistent type is defined (recursively) as a scalar type, an untagged
2280 -- record whose components are all of a potentially persistent type, or an
2281 -- array with all static constraints whose component type is potentially
2282 -- persistent. A private type is potentially persistent if the full type
2283 -- is potentially persistent.
2285 function Is_Predefined_Dispatching_Operation
(E
: Entity_Id
) return Boolean;
2286 -- Ada 2005 (AI-251): Determines if E is a predefined primitive operation
2288 function Is_Predefined_Interface_Primitive
(E
: Entity_Id
) return Boolean;
2289 -- Ada 2005 (AI-345): Returns True if E is one of the predefined primitives
2290 -- required to implement interfaces.
2292 function Is_Predefined_Internal_Operation
(E
: Entity_Id
) return Boolean;
2293 -- Similar to the previous one, but excludes stream operations, because
2294 -- these may be overridden, and need extra formals, like user-defined
2297 function Is_Preelaborable_Aggregate
(Aggr
: Node_Id
) return Boolean;
2298 -- Determine whether aggregate Aggr violates the restrictions of
2299 -- preelaborable constructs as defined in ARM 10.2.1(5-9).
2301 function Is_Preelaborable_Construct
(N
: Node_Id
) return Boolean;
2302 -- Determine whether arbitrary node N violates the restrictions of
2303 -- preelaborable constructs as defined in ARM 10.2.1(5-9). Routine
2304 -- Is_Non_Preelaborable_Construct takes into account the syntactic
2305 -- and semantic properties of N for a more accurate diagnostic.
2307 function Is_Private_Library_Unit
(Unit
: Entity_Id
) return Boolean;
2308 -- Returns True if and only if the library unit is declared with an
2309 -- explicit designation of private.
2311 function Is_Protected_Self_Reference
(N
: Node_Id
) return Boolean;
2312 -- Return True if node N denotes a protected type name which represents
2313 -- the current instance of a protected object according to RM 9.4(21/2).
2315 function Is_RCI_Pkg_Spec_Or_Body
(Cunit
: Node_Id
) return Boolean;
2316 -- Return True if a compilation unit is the specification or the
2317 -- body of a remote call interface package.
2319 function Is_Remote_Access_To_Class_Wide_Type
(E
: Entity_Id
) return Boolean;
2320 -- Return True if E is a remote access-to-class-wide type
2322 function Is_Remote_Access_To_Subprogram_Type
(E
: Entity_Id
) return Boolean;
2323 -- Return True if E is a remote access to subprogram type
2325 function Is_Remote_Call
(N
: Node_Id
) return Boolean;
2326 -- Return True if N denotes a potentially remote call
2328 function Is_Renamed_Entry
(Proc_Nam
: Entity_Id
) return Boolean;
2329 -- Return True if Proc_Nam is a procedure renaming of an entry
2331 function Is_Reversible_Iterator
(Typ
: Entity_Id
) return Boolean;
2332 -- AI05-0139-2: Check whether Typ is derived from the predefined interface
2333 -- Ada.Iterator_Interfaces.Reversible_Iterator.
2335 function Is_Selector_Name
(N
: Node_Id
) return Boolean;
2336 -- Given an N_Identifier node N, determines if it is a Selector_Name.
2337 -- As described in Sinfo, Selector_Names are special because they
2338 -- represent use of the N_Identifier node for a true identifier, when
2339 -- normally such nodes represent a direct name.
2341 function Is_Single_Concurrent_Object
(Id
: Entity_Id
) return Boolean;
2342 -- Determine whether arbitrary entity Id denotes the anonymous object
2343 -- created for a single protected or single task type.
2345 function Is_Single_Concurrent_Type
(Id
: Entity_Id
) return Boolean;
2346 -- Determine whether arbitrary entity Id denotes a single protected or
2347 -- single task type.
2349 function Is_Single_Concurrent_Type_Declaration
(N
: Node_Id
) return Boolean;
2350 -- Determine whether arbitrary node N denotes the declaration of a single
2351 -- protected type or single task type.
2353 function Is_Single_Precision_Floating_Point_Type
2354 (E
: Entity_Id
) return Boolean;
2355 -- Return whether E is a single precision floating point type,
2356 -- characterized by:
2357 -- . machine_radix = 2
2358 -- . machine_mantissa = 24
2359 -- . machine_emax = 2**7
2360 -- . machine_emin = 3 - machine_emax
2362 function Is_Single_Protected_Object
(Id
: Entity_Id
) return Boolean;
2363 -- Determine whether arbitrary entity Id denotes the anonymous object
2364 -- created for a single protected type.
2366 function Is_Single_Task_Object
(Id
: Entity_Id
) return Boolean;
2367 -- Determine whether arbitrary entity Id denotes the anonymous object
2368 -- created for a single task type.
2370 function Is_Special_Aliased_Formal_Access
2372 In_Return_Context
: Boolean := False) return Boolean;
2373 -- Determines whether a dynamic check must be generated for explicitly
2374 -- aliased formals within a function Scop for the expression Exp.
2376 -- In_Return_Context forces Is_Special_Aliased_Formal_Access to assume
2377 -- that Exp is within a return value which is useful for checking
2378 -- expressions within discriminant associations of return objects.
2380 -- More specially, Is_Special_Aliased_Formal_Access checks that Exp is a
2381 -- 'Access attribute reference within a return statement where the ultimate
2382 -- prefix is an aliased formal of Scop and that Scop returns an anonymous
2383 -- access type. See RM 3.10.2 for more details.
2385 function Is_Specific_Tagged_Type
(Typ
: Entity_Id
) return Boolean;
2386 -- Determine whether an arbitrary [private] type is specifically tagged
2388 function Is_Statement
(N
: Node_Id
) return Boolean;
2389 pragma Inline
(Is_Statement
);
2390 -- Check if the node N is a statement node. Note that this includes
2391 -- the case of procedure call statements (unlike the direct use of
2392 -- the N_Statement_Other_Than_Procedure_Call subtype from Sinfo).
2393 -- Note that a label is *not* a statement, and will return False.
2395 function Is_Static_Discriminant_Component
(N
: Node_Id
) return Boolean;
2396 -- Return True if N is guaranteed to a selected component containing a
2397 -- statically known discriminant.
2398 -- Note that this routine takes a conservative view and may return False
2399 -- in some cases where N would match the criteria. In other words this
2400 -- routine should be used to simplify or optimize the expanded code.
2402 function Is_Static_Function
(Subp
: Entity_Id
) return Boolean;
2403 -- Determine whether subprogram Subp denotes a static function,
2404 -- which is a function with the aspect Static with value True.
2406 function Is_Static_Function_Call
(Call
: Node_Id
) return Boolean;
2407 -- Determine whether Call is a static call to a static function,
2408 -- meaning that the name of the call denotes a static function
2409 -- and all of the call's actual parameters are given by static expressions.
2411 function Is_Subcomponent_Of_Full_Access_Object
(N
: Node_Id
) return Boolean;
2412 -- Determine whether arbitrary node N denotes a reference to a subcomponent
2413 -- of a full access object as per RM C.6(7).
2415 function Is_Subprogram_Contract_Annotation
(Item
: Node_Id
) return Boolean;
2416 -- Determine whether aspect specification or pragma Item is one of the
2417 -- following subprogram contract annotations:
2420 -- Extensions_Visible
2431 -- Subprogram_Variant
2434 function Is_Subprogram_Stub_Without_Prior_Declaration
2435 (N
: Node_Id
) return Boolean;
2436 -- Given an N_Subprogram_Body_Stub node N, return True if N is a subprogram
2437 -- stub with no prior subprogram declaration.
2439 function Is_Suitable_Primitive
(Subp_Id
: Entity_Id
) return Boolean;
2440 -- Determine whether arbitrary subprogram Subp_Id may act as a primitive of
2441 -- an arbitrary tagged type.
2443 function Is_Synchronized_Object
(Id
: Entity_Id
) return Boolean;
2444 -- Determine whether entity Id denotes an object and if it does, whether
2445 -- this object is synchronized as specified in SPARK RM 9.1. To qualify as
2446 -- such, the object must be
2447 -- * Of a type that yields a synchronized object
2448 -- * An atomic object with enabled Async_Writers
2449 -- * A constant not of access-to-variable type
2450 -- * A variable subject to pragma Constant_After_Elaboration
2452 function Is_Synchronized_Tagged_Type
(E
: Entity_Id
) return Boolean;
2453 -- Returns True if E is a synchronized tagged type (AARM 3.9.4 (6/2))
2455 function Is_Transfer
(N
: Node_Id
) return Boolean;
2456 -- Returns True if the node N is a statement which is known to cause an
2457 -- unconditional transfer of control at run time, i.e. the following
2458 -- statement definitely will not be executed.
2460 function Is_Unchecked_Conversion_Instance
(Id
: Entity_Id
) return Boolean;
2461 -- Determine whether an arbitrary entity denotes an instance of function
2462 -- Ada.Unchecked_Conversion.
2464 function Is_Universal_Numeric_Type
(T
: Entity_Id
) return Boolean;
2465 pragma Inline
(Is_Universal_Numeric_Type
);
2466 -- True if T is Universal_Integer or Universal_Real
2468 function Is_User_Defined_Equality
(Id
: Entity_Id
) return Boolean;
2469 -- Determine whether an entity denotes a user-defined equality
2471 function Is_Validation_Variable_Reference
(N
: Node_Id
) return Boolean;
2472 -- Determine whether N denotes a reference to a variable which captures the
2473 -- value of an object for validation purposes.
2475 function Is_Variable_Size_Array
(E
: Entity_Id
) return Boolean;
2476 -- Returns true if E has variable size components
2478 function Is_Variable_Size_Record
(E
: Entity_Id
) return Boolean;
2479 -- Returns true if E has variable size components
2481 -- WARNING: There is a matching C declaration of this subprogram in fe.h
2483 function Is_Variable
2485 Use_Original_Node
: Boolean := True) return Boolean;
2486 -- Determines if the tree referenced by N represents a variable, i.e. can
2487 -- appear on the left side of an assignment. There is one situation (formal
2488 -- parameters) in which untagged type conversions are also considered
2489 -- variables, but Is_Variable returns False for such cases, since it has
2490 -- no knowledge of the context. Note that this is the point at which
2491 -- Assignment_OK is checked, and True is returned for any tree thus marked.
2492 -- Use_Original_Node is used to perform the test on Original_Node (N). By
2493 -- default is True since this routine is commonly invoked as part of the
2494 -- semantic analysis and it must not be disturbed by the rewriten nodes.
2496 function Is_View_Conversion
(N
: Node_Id
) return Boolean;
2497 -- Returns True if N is a type_conversion whose operand is the name of an
2498 -- object and both its target type and operand type are tagged, or it
2499 -- appears in a call as an actual parameter of mode out or in out
2502 function Is_Visibly_Controlled
(T
: Entity_Id
) return Boolean;
2503 -- Check whether T is derived from a visibly controlled type. This is true
2504 -- if the root type is declared in Ada.Finalization. If T is derived
2505 -- instead from a private type whose full view is controlled, an explicit
2506 -- Initialize/Adjust/Finalize subprogram does not override the inherited
2509 function Is_Volatile_Full_Access_Object_Ref
(N
: Node_Id
) return Boolean;
2510 -- Determine whether arbitrary node N denotes a reference to an object
2511 -- which is Volatile_Full_Access.
2513 function Is_Volatile_Function
(Func_Id
: Entity_Id
) return Boolean;
2514 -- Determine whether [generic] function Func_Id is subject to enabled
2515 -- pragma Volatile_Function. Protected functions are treated as volatile
2516 -- (SPARK RM 7.1.2).
2518 function Is_Volatile_Object_Ref
(N
: Node_Id
) return Boolean;
2519 -- Determine whether arbitrary node N denotes a reference to a volatile
2520 -- object as per RM C.6(8). Note that the test here is for something that
2521 -- is actually declared as volatile, not for an object that gets treated
2522 -- as volatile (see Einfo.Treat_As_Volatile).
2525 with procedure Handle_Parameter
(Formal
: Entity_Id
; Actual
: Node_Id
);
2526 procedure Iterate_Call_Parameters
(Call
: Node_Id
);
2527 -- Calls Handle_Parameter for each pair of formal and actual parameters of
2528 -- a function, procedure, or entry call.
2530 function Itype_Has_Declaration
(Id
: Entity_Id
) return Boolean;
2531 -- Applies to Itypes. True if the Itype is attached to a declaration for
2532 -- the type through its Parent field, which may or not be present in the
2535 procedure Kill_Current_Values
(Last_Assignment_Only
: Boolean := False);
2536 -- This procedure is called to clear all constant indications from all
2537 -- entities in the current scope and in any parent scopes if the current
2538 -- scope is a block or a package (and that recursion continues to the top
2539 -- scope that is not a block or a package). This is used when the
2540 -- sequential flow-of-control assumption is violated (occurrence of a
2541 -- label, head of a loop, or start of an exception handler). The effect of
2542 -- the call is to clear the Current_Value field (but we do not need to
2543 -- clear the Is_True_Constant flag, since that only gets reset if there
2544 -- really is an assignment somewhere in the entity scope). This procedure
2545 -- also calls Kill_All_Checks, since this is a special case of needing to
2546 -- forget saved values. This procedure also clears the Is_Known_Null and
2547 -- Is_Known_Non_Null and Is_Known_Valid flags in variables, constants or
2548 -- parameters since these are also not known to be trustable any more.
2550 -- The Last_Assignment_Only flag is set True to clear only Last_Assignment
2551 -- fields and leave other fields unchanged. This is used when we encounter
2552 -- an unconditional flow of control change (return, goto, raise). In such
2553 -- cases we don't need to clear the current values, since it may be that
2554 -- the flow of control change occurs in a conditional context, and if it
2555 -- is not taken, then it is just fine to keep the current values. But the
2556 -- Last_Assignment field is different, if we have a sequence assign-to-v,
2557 -- conditional-return, assign-to-v, we do not want to complain that the
2558 -- second assignment clobbers the first.
2560 procedure Kill_Current_Values
2562 Last_Assignment_Only
: Boolean := False);
2563 -- This performs the same processing as described above for the form with
2564 -- no argument, but for the specific entity given. The call has no effect
2565 -- if the entity Ent is not for an object. Last_Assignment_Only has the
2566 -- same meaning as for the call with no Ent.
2568 procedure Kill_Size_Check_Code
(E
: Entity_Id
);
2569 -- Called when an address clause or pragma Import is applied to an entity.
2570 -- If the entity is a variable or a constant, and size check code is
2571 -- present, this size check code is killed, since the object will not be
2572 -- allocated by the program.
2574 function Known_Non_Null
(N
: Node_Id
) return Boolean;
2575 -- Given a node N for a subexpression of an access type, determines if
2576 -- this subexpression yields a value that is known at compile time to
2577 -- be non-null and returns True if so. Returns False otherwise. It is
2578 -- an error to call this function if N is not of an access type.
2580 function Known_Null
(N
: Node_Id
) return Boolean;
2581 -- Given a node N for a subexpression of an access type, determines if this
2582 -- subexpression yields a value that is known at compile time to be null
2583 -- and returns True if so. Returns False otherwise. It is an error to call
2584 -- this function if N is not of an access type.
2586 function Known_To_Be_Assigned
(N
: Node_Id
) return Boolean;
2587 -- The node N is an entity reference. This function determines whether the
2588 -- reference is for sure an assignment of the entity, returning True if
2589 -- so. This differs from May_Be_Lvalue in that it defaults in the other
2590 -- direction. Cases which may possibly be assignments but are not known to
2591 -- be may return True from May_Be_Lvalue, but False from this function.
2593 function Last_Source_Statement
(HSS
: Node_Id
) return Node_Id
;
2594 -- HSS is a handled statement sequence. This function returns the last
2595 -- statement in Statements (HSS) that has Comes_From_Source set. If no
2596 -- such statement exists, Empty is returned.
2598 procedure Mark_Coextensions
(Context_Nod
: Node_Id
; Root_Nod
: Node_Id
);
2599 -- Given a node which designates the context of analysis and an origin in
2600 -- the tree, traverse from Root_Nod and mark all allocators as either
2601 -- dynamic or static depending on Context_Nod. Any incorrect marking is
2602 -- cleaned up during resolution.
2604 procedure Mark_Elaboration_Attributes
2605 (N_Id
: Node_Or_Entity_Id
;
2606 Checks
: Boolean := False;
2607 Level
: Boolean := False;
2608 Modes
: Boolean := False;
2609 Warnings
: Boolean := False);
2610 -- Preserve relevant elaboration-related properties of the context in
2611 -- arbitrary entity or node N_Id. The flags control the properties as
2614 -- Checks - Save the status of Elaboration_Check
2615 -- Level - Save the declaration level of N_Id (if appicable)
2616 -- Modes - Save the Ghost and SPARK modes in effect (if applicable)
2617 -- Warnings - Save the status of Elab_Warnings
2619 procedure Mark_Save_Invocation_Graph_Of_Body
;
2620 -- Notify the body of the main unit that the invocation constructs and
2621 -- relations expressed within it must be recorded by the ABE mechanism.
2623 function Matching_Static_Array_Bounds
2625 R_Typ
: Node_Id
) return Boolean;
2626 -- L_Typ and R_Typ are two array types. Returns True when they have the
2627 -- same number of dimensions, and the same static bounds for each index
2630 function May_Be_Lvalue
(N
: Node_Id
) return Boolean;
2631 -- Determines if N could be an lvalue (e.g. an assignment left hand side).
2632 -- An lvalue is defined as any expression which appears in a context where
2633 -- a name is required by the syntax, and the identity, rather than merely
2634 -- the value of the node is needed (for example, the prefix of an Access
2635 -- attribute is in this category). Note that, as implied by the name, this
2636 -- test is conservative. If it cannot be sure that N is NOT an lvalue, then
2637 -- it returns True. It tries hard to get the answer right, but it is hard
2638 -- to guarantee this in all cases. Note that it is more possible to give
2639 -- correct answer if the tree is fully analyzed.
2641 function Might_Raise
(N
: Node_Id
) return Boolean;
2642 -- True if evaluation of N might raise an exception. This is conservative;
2643 -- if we're not sure, we return True. If N is a subprogram body, this is
2644 -- about whether execution of that body can raise.
2646 function Nearest_Class_Condition_Subprogram
2647 (Kind
: Condition_Kind
;
2648 Spec_Id
: Entity_Id
) return Entity_Id
;
2649 -- Return the nearest ancestor containing the merged class-wide conditions
2650 -- that statically apply to Spec_Id; return Empty otherwise.
2652 function Nearest_Enclosing_Instance
(E
: Entity_Id
) return Entity_Id
;
2653 -- Return the entity of the nearest enclosing instance which encapsulates
2654 -- entity E. If no such instance exits, return Empty.
2656 function Needs_Finalization
(Typ
: Entity_Id
) return Boolean;
2657 -- True if Typ requires finalization actions
2659 function Needs_One_Actual
(E
: Entity_Id
) return Boolean;
2660 -- Returns True if a function has defaults for all but its first formal,
2661 -- which is a controlling formal. Used in Ada 2005 mode to solve the
2662 -- syntactic ambiguity that results from an indexing of a function call
2663 -- that returns an array, so that Obj.F (X, Y) may mean F (Ob) (X, Y).
2665 function Needs_Result_Accessibility_Level
2666 (Func_Id
: Entity_Id
) return Boolean;
2667 -- Ada 2012 (AI05-0234): Return True if the function needs an implicit
2668 -- parameter to identify the accessibility level of the function result
2669 -- "determined by the point of call".
2671 function Needs_Simple_Initialization
2673 Consider_IS
: Boolean := True) return Boolean;
2674 -- Certain types need initialization even though there is no specific
2675 -- initialization routine:
2676 -- Access types (which need initializing to null)
2677 -- All scalar types if Normalize_Scalars mode set
2678 -- Descendants of standard string types if Normalize_Scalars mode set
2679 -- Scalar types having a Default_Value attribute
2680 -- Regarding Initialize_Scalars mode, this is ignored if Consider_IS is
2681 -- set to False, but if Consider_IS is set to True, then the cases above
2682 -- mentioning Normalize_Scalars also apply for Initialize_Scalars mode.
2684 function Needs_Variable_Reference_Marker
2686 Calls_OK
: Boolean) return Boolean;
2687 -- Determine whether arbitrary node N denotes a reference to a variable
2688 -- which is suitable for SPARK elaboration checks. Flag Calls_OK should
2689 -- be set when the reference is allowed to appear within calls.
2691 function New_Copy_List_Tree
(List
: List_Id
) return List_Id
;
2692 -- Copy recursively an analyzed list of nodes. Uses New_Copy_Tree defined
2693 -- below. As for New_Copy_Tree, it is illegal to attempt to copy extended
2694 -- nodes (entities) either directly or indirectly using this function.
2696 function New_Copy_Separate_List
(List
: List_Id
) return List_Id
;
2697 -- Copy recursively a list of nodes using New_Copy_Separate_Tree
2699 function New_Copy_Separate_Tree
(Source
: Node_Id
) return Node_Id
;
2700 -- Perform a deep copy of the subtree rooted at Source using New_Copy_Tree
2701 -- replacing entities of local declarations by new entities. This behavior
2702 -- is required by the backend to ensure entities uniqueness when a copy of
2703 -- a subtree is attached to the tree. The new entities keep their original
2704 -- names to facilitate debugging the tree copy.
2706 function New_Copy_Tree
2708 Map
: Elist_Id
:= No_Elist
;
2709 New_Sloc
: Source_Ptr
:= No_Location
;
2710 New_Scope
: Entity_Id
:= Empty
;
2711 Scopes_In_EWA_OK
: Boolean := False) return Node_Id
;
2712 -- Perform a deep copy of the subtree rooted at Source. Entities, itypes,
2713 -- and nodes are handled separately as follows:
2715 -- * A node is replicated by first creating a shallow copy, then copying
2716 -- its syntactic fields, where all Parent pointers of the fields are
2717 -- updated to refer to the copy. In addition, the following semantic
2718 -- fields are recreated after the replication takes place.
2720 -- First_Named_Actual
2721 -- First_Real_Statement
2722 -- Next_Named_Actual
2724 -- If applicable, the Etype field (if any) is updated to refer to a
2725 -- local itype or type (see below).
2727 -- * An entity defined within an N_Expression_With_Actions node in the
2728 -- subtree is given a new entity, and all references to the original
2729 -- entity are updated to refer to the new entity. In addition, the
2730 -- following semantic fields are replicated and/or updated to refer
2731 -- to a local entity or itype.
2733 -- Discriminant_Constraint
2737 -- Packed_Array_Impl_Type
2741 -- Note that currently no other expression can define entities.
2743 -- * An itype whose Associated_Node_For_Itype node is in the subtree
2744 -- is given a new entity, and all references to the original itype
2745 -- are updated to refer to the new itype. In addition, the following
2746 -- semantic fields are replicated and/or updated to refer to a local
2749 -- Discriminant_Constraint
2753 -- Packed_Array_Impl_Type
2757 -- The Associated_Node_For_Itype is updated to refer to a replicated
2760 -- The routine can replicate both analyzed and unanalyzed trees. Copying an
2761 -- Empty or Error node yields the same node.
2763 -- Parameter Map may be used to specify a set of mappings between entities.
2764 -- These mappings are then taken into account when replicating entities.
2765 -- The format of Map must be as follows:
2768 -- new entity to replace references to entity 1
2770 -- new entity to replace references to entity 2
2773 -- Map and its contents are left unchanged.
2775 -- Parameter New_Sloc may be used to specify a new source location for all
2776 -- replicated entities, itypes, and nodes. The Comes_From_Source indicator
2777 -- is defaulted if a new source location is provided.
2779 -- Parameter New_Scope may be used to specify a new scope for all copied
2780 -- entities and itypes.
2782 -- Parameter Scopes_In_EWA_OK may be used to force the replication of both
2783 -- scoping entities and non-scoping entities found within expression with
2786 function New_External_Entity
2787 (Kind
: Entity_Kind
;
2788 Scope_Id
: Entity_Id
;
2789 Sloc_Value
: Source_Ptr
;
2790 Related_Id
: Entity_Id
;
2792 Suffix_Index
: Int
:= 0;
2793 Prefix
: Character := ' ') return Entity_Id
;
2794 -- This function creates an N_Defining_Identifier node for an internal
2795 -- created entity, such as an implicit type or subtype, or a record
2796 -- initialization procedure. The entity name is constructed with a call
2797 -- to New_External_Name (Related_Id, Suffix, Suffix_Index, Prefix), so
2798 -- that the generated name may be referenced as a public entry, and the
2799 -- Is_Public flag is set if needed (using Set_Public_Status). If the
2800 -- entity is for a type or subtype, the size/align fields are initialized
2801 -- to unknown (Uint_0).
2803 function New_Internal_Entity
2804 (Kind
: Entity_Kind
;
2805 Scope_Id
: Entity_Id
;
2806 Sloc_Value
: Source_Ptr
;
2807 Id_Char
: Character) return Entity_Id
;
2808 -- This function is similar to New_External_Entity, except that the
2809 -- name is constructed by New_Internal_Name (Id_Char). This is used
2810 -- when the resulting entity does not have to be referenced as a
2811 -- public entity (and in this case Is_Public is not set).
2813 function Next_Actual
(Actual_Id
: Node_Id
) return Node_Id
;
2814 -- Find next actual parameter in declaration order. As described for
2815 -- First_Actual, this is the next actual in the declaration order, not
2816 -- the call order, so this does not correspond to simply taking the
2817 -- next entry of the Parameter_Associations list. The argument is an
2818 -- actual previously returned by a call to First_Actual or Next_Actual.
2819 -- Note that the result produced is always an expression, not a parameter
2820 -- association node, even if named notation was used.
2822 -- WARNING: There is a matching C declaration of this subprogram in fe.h
2824 procedure Next_Actual
(Actual_Id
: in out Node_Id
);
2825 pragma Inline
(Next_Actual
);
2826 -- Next_Actual (N) is equivalent to N := Next_Actual (N). Note that we
2827 -- inline this procedural form, but not the functional form above.
2829 function Next_Global
(Node
: Node_Id
) return Node_Id
;
2830 -- Node is a global item from a list, obtained through calling First_Global
2831 -- and possibly Next_Global a number of times. Returns the next global item
2832 -- with the same mode.
2834 procedure Next_Global
(Node
: in out Node_Id
);
2835 pragma Inline
(Next_Global
);
2836 -- Next_Global (N) is equivalent to N := Next_Global (N). Note that we
2837 -- inline this procedural form, but not the functional form above.
2839 function No_Caching_Enabled
(Id
: Entity_Id
) return Boolean;
2840 -- Given the entity of a variable, determine whether Id is subject to
2841 -- volatility property No_Caching and if it is, the related expression
2842 -- evaluates to True.
2844 function No_Heap_Finalization
(Typ
: Entity_Id
) return Boolean;
2845 -- Determine whether type Typ is subject to pragma No_Heap_Finalization
2847 procedure Normalize_Actuals
2851 Success
: out Boolean);
2852 -- Reorders lists of actuals according to names of formals, value returned
2853 -- in Success indicates success of reordering. For more details, see body.
2854 -- Errors are reported only if Report is set to True.
2856 procedure Note_Possible_Modification
(N
: Node_Id
; Sure
: Boolean);
2857 -- This routine is called if the sub-expression N maybe the target of
2858 -- an assignment (e.g. it is the left side of an assignment, used as
2859 -- an out parameters, or used as prefixes of access attributes). It
2860 -- sets May_Be_Modified in the associated entity if there is one,
2861 -- taking into account the rule that in the case of renamed objects,
2862 -- it is the flag in the renamed object that must be set.
2864 -- The parameter Sure is set True if the modification is sure to occur
2865 -- (e.g. target of assignment, or out parameter), and to False if the
2866 -- modification is only potential (e.g. address of entity taken).
2868 function Null_To_Null_Address_Convert_OK
2870 Typ
: Entity_Id
:= Empty
) return Boolean;
2871 -- Return True if we are compiling in relaxed RM semantics mode and:
2872 -- 1) N is a N_Null node and Typ is a descendant of System.Address, or
2873 -- 2) N is a comparison operator, one of the operands is null, and the
2874 -- type of the other operand is a descendant of System.Address.
2876 function Number_Of_Elements_In_Array
(T
: Entity_Id
) return Int
;
2877 -- Returns the number of elements in the array T if the index bounds of T
2878 -- is known at compile time. If the bounds are not known at compile time,
2879 -- the function returns the value zero.
2881 function Original_Aspect_Pragma_Name
(N
: Node_Id
) return Name_Id
;
2882 -- Retrieve the name of aspect or pragma N, taking into account a possible
2883 -- rewrite and whether the pragma is generated from an aspect as the names
2884 -- may be different. The routine also deals with 'Class in which case it
2885 -- returns the following values:
2887 -- Invariant -> Name_uInvariant
2888 -- Post'Class -> Name_uPost
2889 -- Pre'Class -> Name_uPre
2890 -- Type_Invariant -> Name_uType_Invariant
2891 -- Type_Invariant'Class -> Name_uType_Invariant
2893 function Original_Corresponding_Operation
(S
: Entity_Id
) return Entity_Id
;
2894 -- [Ada 2012: AI05-0125-1]: If S is an inherited dispatching primitive S2,
2895 -- or overrides an inherited dispatching primitive S2, the original
2896 -- corresponding operation of S is the original corresponding operation of
2897 -- S2. Otherwise, it is S itself.
2899 function Original_View_In_Visible_Part
(Typ
: Entity_Id
) return Boolean;
2900 -- Returns True if the type Typ has a private view or if the public view
2901 -- appears in the visible part of a package spec.
2903 procedure Output_Entity
(Id
: Entity_Id
);
2904 -- Print entity Id to standard output. The name of the entity appears in
2905 -- fully qualified form.
2907 -- WARNING: this routine should be used in debugging scenarios such as
2908 -- tracking down undefined symbols as it is fairly low level.
2910 procedure Output_Name
(Nam
: Name_Id
; Scop
: Entity_Id
:= Current_Scope
);
2911 -- Print name Nam to standard output. The name appears in fully qualified
2912 -- form assuming it appears in scope Scop. Note that this may not reflect
2913 -- the final qualification as the entity which carries the name may be
2914 -- relocated to a different scope.
2916 -- WARNING: this routine should be used in debugging scenarios such as
2917 -- tracking down undefined symbols as it is fairly low level.
2919 function Param_Entity
(N
: Node_Id
) return Entity_Id
;
2920 -- Given an expression N, determines if the expression is a reference
2921 -- to a formal (of a subprogram or entry), and if so returns the Id
2922 -- of the corresponding formal entity, otherwise returns Empty. Also
2923 -- handles the case of references to renamings of formals.
2925 function Policy_In_Effect
(Policy
: Name_Id
) return Name_Id
;
2926 -- Given a policy, return the policy identifier associated with it. If no
2927 -- such policy is in effect, the value returned is No_Name.
2929 function Predicate_Enabled
(Typ
: Entity_Id
) return Boolean;
2930 -- Return True if a predicate check should be emitted for the given type
2931 -- Typ, taking into account Predicates_Ignored and
2932 -- Predicate_Checks_Suppressed.
2934 function Predicate_Tests_On_Arguments
(Subp
: Entity_Id
) return Boolean;
2935 -- Subp is the entity for a subprogram call. This function returns True if
2936 -- predicate tests are required for the arguments in this call (this is the
2937 -- normal case). It returns False for special cases where these predicate
2938 -- tests should be skipped (see body for details).
2940 function Primitive_Names_Match
(E1
, E2
: Entity_Id
) return Boolean;
2941 -- Returns True if the names of both entities correspond with matching
2942 -- primitives. This routine includes support for the case in which one
2943 -- or both entities correspond with entities built by Derive_Subprogram
2944 -- with a special name to avoid being overridden (i.e. return true in case
2945 -- of entities with names "nameP" and "name" or vice versa).
2947 function Private_Component
(Type_Id
: Entity_Id
) return Entity_Id
;
2948 -- Returns some private component (if any) of the given Type_Id.
2949 -- Used to enforce the rules on visibility of operations on composite
2950 -- types, that depend on the full view of the component type. For a
2951 -- record type there may be several such components, we just return
2954 procedure Process_End_Label
2958 -- N is a node whose End_Label is to be processed, generating all
2959 -- appropriate cross-reference entries, and performing style checks
2960 -- for any identifier references in the end label. Typ is either
2961 -- 'e' or 't indicating the type of the cross-reference entity
2962 -- (e for spec, t for body, see Lib.Xref spec for details). The
2963 -- parameter Ent gives the entity to which the End_Label refers,
2964 -- and to which cross-references are to be generated.
2966 procedure Propagate_Concurrent_Flags
2968 Comp_Typ
: Entity_Id
);
2969 -- Set Has_Task, Has_Protected, and Has_Timing_Event on Typ when the flags
2970 -- are set on Comp_Typ. This follows the definition of these flags, which
2971 -- are set (recursively) on any composite type that has a component marked
2972 -- by one of these flags. This procedure can only set flags for Typ, and
2973 -- never clear them. Comp_Typ is the type of a component or a parent.
2975 procedure Propagate_DIC_Attributes
2977 From_Typ
: Entity_Id
);
2978 -- Inherit all Default_Initial_Condition-related attributes from type
2979 -- From_Typ. Typ is the destination type.
2981 procedure Propagate_Invariant_Attributes
2983 From_Typ
: Entity_Id
);
2984 -- Inherit all invariant-related attributes from type From_Typ. Typ is the
2985 -- destination type.
2987 procedure Propagate_Predicate_Attributes
2989 From_Typ
: Entity_Id
);
2990 -- Inherit predicate functions and Has_Predicates flag from type From_Typ.
2991 -- Typ is the destination type.
2993 procedure Record_Possible_Part_Of_Reference
2994 (Var_Id
: Entity_Id
;
2996 -- Save reference Ref to variable Var_Id when the variable is subject to
2997 -- pragma Part_Of. If the variable is known to be a constituent of a single
2998 -- protected/task type, the legality of the reference is verified and the
2999 -- save does not take place.
3001 function Referenced
(Id
: Entity_Id
; Expr
: Node_Id
) return Boolean;
3002 -- Determine whether entity Id is referenced within expression Expr
3004 function References_Generic_Formal_Type
(N
: Node_Id
) return Boolean;
3005 -- Returns True if the expression Expr contains any references to a generic
3006 -- type. This can only happen within a generic template.
3008 procedure Remove_Entity_And_Homonym
(Id
: Entity_Id
);
3009 -- Remove arbitrary entity Id from both the homonym and scope chains. Use
3010 -- Remove_Overloaded_Entity for overloadable entities. Note: the removal
3011 -- performed by this routine does not affect the visibility of existing
3014 procedure Remove_Homonym
(Id
: Entity_Id
);
3015 -- Removes entity Id from the homonym chain
3017 procedure Remove_Overloaded_Entity
(Id
: Entity_Id
);
3018 -- Remove arbitrary entity Id from the homonym chain, the scope chain and
3019 -- the primitive operations list of the associated controlling type. Use
3020 -- Remove_Entity for non-overloadable entities. Note: the removal performed
3021 -- by this routine does not affect the visibility of existing homonyms.
3023 function Remove_Suffix
(E
: Entity_Id
; Suffix
: Character) return Name_Id
;
3024 -- Returns the name of E without Suffix
3026 procedure Replace_Null_By_Null_Address
(N
: Node_Id
);
3027 -- N is N_Null or a binary comparison operator, we are compiling in relaxed
3028 -- RM semantics mode, and one of the operands is null. Replace null with
3029 -- System.Null_Address.
3031 function Rep_To_Pos_Flag
(E
: Entity_Id
; Loc
: Source_Ptr
) return Node_Id
;
3032 -- This is used to construct the second argument in a call to Rep_To_Pos
3033 -- which is Standard_True if range checks are enabled (E is an entity to
3034 -- which the Range_Checks_Suppressed test is applied), and Standard_False
3035 -- if range checks are suppressed. Loc is the location for the node that
3036 -- is returned (which is a New_Occurrence of the appropriate entity).
3038 -- Note: one might think that it would be fine to always use True and
3039 -- to ignore the suppress in this case, but it is generally better to
3040 -- believe a request to suppress exceptions if possible, and further
3041 -- more there is at least one case in the generated code (the code for
3042 -- array assignment in a loop) that depends on this suppression.
3044 procedure Require_Entity
(N
: Node_Id
);
3045 -- N is a node which should have an entity value if it is an entity name.
3046 -- If not, then check if there were previous errors. If so, just fill
3047 -- in with Any_Id and ignore. Otherwise signal a program error exception.
3048 -- This is used as a defense mechanism against ill-formed trees caused by
3049 -- previous errors (particularly in -gnatq mode).
3051 function Requires_Transient_Scope
(Id
: Entity_Id
) return Boolean;
3052 -- Id is a type entity. The result is True when temporaries of this type
3053 -- need to be wrapped in a transient scope to be reclaimed properly when a
3054 -- secondary stack is in use. Examples of types requiring such wrapping are
3055 -- controlled types and variable-sized types including unconstrained
3058 -- WARNING: There is a matching C declaration of this subprogram in fe.h
3060 procedure Reset_Analyzed_Flags
(N
: Node_Id
);
3061 -- Reset the Analyzed flags in all nodes of the tree whose root is N
3063 procedure Restore_SPARK_Mode
(Mode
: SPARK_Mode_Type
; Prag
: Node_Id
);
3064 -- Set the current SPARK_Mode to Mode and SPARK_Mode_Pragma to Prag. This
3065 -- routine must be used in tandem with Set_SPARK_Mode.
3067 function Returns_Unconstrained_Type
(Subp
: Entity_Id
) return Boolean;
3068 -- Return true if Subp is a function that returns an unconstrained type
3070 function Root_Type_Of_Full_View
(T
: Entity_Id
) return Entity_Id
;
3071 -- Similar to attribute Root_Type, but this version always follows the
3072 -- Full_View of a private type (if available) while searching for the
3073 -- ultimate derivation ancestor.
3075 function Safe_To_Capture_Value
3078 Cond
: Boolean := False) return Boolean;
3079 -- The caller is interested in capturing a value (either the current
3080 -- value, an indication that the value is [non-]null or an indication that
3081 -- the value is valid) for the given entity Ent. This value can only be
3082 -- captured if sequential execution semantics can be properly guaranteed so
3083 -- that a subsequent reference will indeed be sure that this current value
3084 -- indication is correct. The node N is the construct that resulted in the
3085 -- possible capture of the value (this is used to check if we are in a
3088 -- Cond is used to skip the test for being inside a conditional. It is used
3089 -- in the case of capturing values from if/while tests, which already do a
3090 -- proper job of handling scoping issues without this help.
3092 -- The only entities whose values can be captured are OUT and IN OUT formal
3093 -- parameters, and variables unless Cond is True, in which case we also
3094 -- allow IN formals, loop parameters and constants, where we cannot ever
3095 -- capture actual value information, but we can capture conditional tests.
3097 function Same_Name
(N1
, N2
: Node_Id
) return Boolean;
3098 -- Determine if two (possibly expanded) names are the same name. This is
3099 -- a purely syntactic test, and N1 and N2 need not be analyzed.
3101 function Same_Object
(Node1
, Node2
: Node_Id
) return Boolean;
3102 -- Determine if Node1 and Node2 are known to designate the same object.
3103 -- This is a semantic test and both nodes must be fully analyzed. A result
3104 -- of True is decisively correct. A result of False does not necessarily
3105 -- mean that different objects are designated, just that this could not
3106 -- be reliably determined at compile time.
3108 function Same_Or_Aliased_Subprograms
3110 E
: Entity_Id
) return Boolean;
3111 -- Returns True if the subprogram entity S is the same as E or else S is an
3114 function Same_Type
(T1
, T2
: Entity_Id
) return Boolean;
3115 -- Determines if T1 and T2 represent exactly the same type. Two types
3116 -- are the same if they are identical, or if one is an unconstrained
3117 -- subtype of the other, or they are both common subtypes of the same
3118 -- type with identical constraints. The result returned is conservative.
3119 -- It is True if the types are known to be the same, but a result of
3120 -- False is indecisive (e.g. the compiler may not be able to tell that
3121 -- two constraints are identical).
3123 function Same_Value
(Node1
, Node2
: Node_Id
) return Boolean;
3124 -- Determines if Node1 and Node2 are known to be the same value, which is
3125 -- true if they are both compile time known values and have the same value,
3126 -- or if they are the same object (in the sense of function Same_Object).
3127 -- A result of False does not necessarily mean they have different values,
3128 -- just that it is not possible to determine they have the same value.
3130 function Scalar_Part_Present
(Typ
: Entity_Id
) return Boolean;
3131 -- Determine whether arbitrary type Typ is a scalar type, or contains at
3132 -- least one scalar subcomponent.
3134 function Scope_Within
3136 Outer
: Entity_Id
) return Boolean;
3137 -- Determine whether scope Inner appears within scope Outer. Note that
3138 -- scopes are partially ordered, so Scope_Within (A, B) and Scope_Within
3139 -- (B, A) may both return False.
3141 function Scope_Within_Or_Same
3143 Outer
: Entity_Id
) return Boolean;
3144 -- Determine whether scope Inner appears within scope Outer or both denote
3145 -- the same scope. Note that scopes are partially ordered, so Scope_Within
3146 -- (A, B) and Scope_Within (B, A) may both return False.
3148 procedure Set_Current_Entity
(E
: Entity_Id
);
3149 pragma Inline
(Set_Current_Entity
);
3150 -- Establish the entity E as the currently visible definition of its
3151 -- associated name (i.e. the Node_Id associated with its name).
3153 procedure Set_Debug_Info_Defining_Id
(N
: Node_Id
);
3154 -- Call Set_Debug_Info_Needed on Defining_Identifier (N) if it comes
3157 procedure Set_Debug_Info_Needed
(T
: Entity_Id
);
3158 -- Sets the Debug_Info_Needed flag on entity T , and also on any entities
3159 -- that are needed by T (for an object, the type of the object is needed,
3160 -- and for a type, various subsidiary types are needed -- see body for
3161 -- details). Never has any effect on T if the Debug_Info_Off flag is set.
3162 -- This routine should always be used instead of Set_Needs_Debug_Info to
3163 -- ensure that subsidiary entities are properly handled.
3165 procedure Set_Entity_With_Checks
(N
: Node_Id
; Val
: Entity_Id
);
3166 -- This procedure has the same calling sequence as Set_Entity, but it
3167 -- performs additional checks as follows:
3169 -- If Style_Check is set, then it calls a style checking routine which
3170 -- can check identifier spelling style. This procedure also takes care
3171 -- of checking the restriction No_Implementation_Identifiers.
3173 -- If restriction No_Abort_Statements is set, then it checks that the
3174 -- entity is not Ada.Task_Identification.Abort_Task.
3176 -- If restriction No_Dynamic_Attachment is set, then it checks that the
3177 -- entity is not one of the restricted names for this restriction.
3179 -- If restriction No_Long_Long_Integers is set, then it checks that the
3180 -- entity is not Standard.Long_Long_Integer.
3182 -- If restriction No_Implementation_Identifiers is set, then it checks
3183 -- that the entity is not implementation defined.
3185 procedure Set_Invalid_Scalar_Value
3186 (Scal_Typ
: Float_Scalar_Id
;
3188 -- Associate invalid value Value with scalar type Scal_Typ as specified by
3189 -- pragma Initialize_Scalars.
3191 procedure Set_Invalid_Scalar_Value
3192 (Scal_Typ
: Integer_Scalar_Id
;
3194 -- Associate invalid value Value with scalar type Scal_Typ as specified by
3195 -- pragma Initialize_Scalars.
3197 procedure Set_Name_Entity_Id
(Id
: Name_Id
; Val
: Entity_Id
);
3198 pragma Inline
(Set_Name_Entity_Id
);
3199 -- Sets the Entity_Id value associated with the given name, which is the
3200 -- Id of the innermost visible entity with the given name. See the body
3201 -- of package Sem_Ch8 for further details on the handling of visibility.
3203 procedure Set_Next_Actual
(Ass1_Id
: Node_Id
; Ass2_Id
: Node_Id
);
3204 -- The arguments may be parameter associations, whose descendants
3205 -- are the optional formal name and the actual parameter. Positional
3206 -- parameters are already members of a list, and do not need to be
3207 -- chained separately. See also First_Actual and Next_Actual.
3209 procedure Set_Optimize_Alignment_Flags
(E
: Entity_Id
);
3210 pragma Inline
(Set_Optimize_Alignment_Flags
);
3211 -- Sets Optimize_Alignment_Space/Time flags in E from current settings
3213 procedure Set_Public_Status
(Id
: Entity_Id
);
3214 -- If an entity (visible or otherwise) is defined in a library
3215 -- package, or a package that is itself public, then this subprogram
3216 -- labels the entity public as well.
3218 procedure Set_Referenced_Modified
(N
: Node_Id
; Out_Param
: Boolean);
3219 -- N is the node for either a left hand side (Out_Param set to False),
3220 -- or an Out or In_Out parameter (Out_Param set to True). If there is
3221 -- an assignable entity being referenced, then the appropriate flag
3222 -- (Referenced_As_LHS if Out_Param is False, Referenced_As_Out_Parameter
3223 -- if Out_Param is True) is set True, and the other flag set False.
3225 procedure Set_Rep_Info
(T1
: Entity_Id
; T2
: Entity_Id
);
3226 pragma Inline
(Set_Rep_Info
);
3227 -- Copies the Is_Atomic, Is_Independent and Is_Volatile_Full_Access flags
3228 -- from sub(type) entity T2 to (sub)type entity T1, as well as Is_Volatile
3229 -- if T1 is a base type.
3231 procedure Set_Scope_Is_Transient
(V
: Boolean := True);
3232 -- Set the flag Is_Transient of the current scope
3234 procedure Set_Size_Info
(T1
, T2
: Entity_Id
);
3235 pragma Inline
(Set_Size_Info
);
3236 -- Copies the Esize field and Has_Biased_Representation flag from sub(type)
3237 -- entity T2 to (sub)type entity T1. Also copies the Is_Unsigned_Type flag
3238 -- in the fixed-point and discrete cases, and also copies the alignment
3239 -- value from T2 to T1. It does NOT copy the RM_Size field, which must be
3240 -- separately set if this is required to be copied also.
3242 procedure Set_SPARK_Mode
(Context
: Entity_Id
);
3243 -- Establish the SPARK_Mode and SPARK_Mode_Pragma (if any) of a package or
3244 -- a subprogram denoted by Context. This routine must be used in tandem
3245 -- with Restore_SPARK_Mode.
3247 function Scope_Is_Transient
return Boolean;
3248 -- True if the current scope is transient
3250 function Should_Ignore_Pragma_Par
(Prag_Name
: Name_Id
) return Boolean;
3251 function Should_Ignore_Pragma_Sem
(N
: Node_Id
) return Boolean;
3252 -- True if we should ignore pragmas with the specified name. In particular,
3253 -- this returns True if pragma Ignore_Pragma applies, and we are not in a
3254 -- predefined unit. The _Par version should be called only from the parser;
3255 -- the _Sem version should be called only during semantic analysis.
3257 function Static_Boolean
(N
: Node_Id
) return Opt_Ubool
;
3258 -- This function analyzes the given expression node and then resolves it
3259 -- as Standard.Boolean. If the result is static, then Uint_1 or Uint_0 is
3260 -- returned corresponding to the value, otherwise an error message is
3261 -- output and No_Uint is returned.
3263 function Static_Integer
(N
: Node_Id
) return Uint
;
3264 -- This function analyzes the given expression node and then resolves it
3265 -- as any integer type. If the result is static, then the value of the
3266 -- universal expression is returned, otherwise an error message is output
3267 -- and a value of No_Uint is returned.
3269 function Statically_Denotes_Entity
(N
: Node_Id
) return Boolean;
3270 -- Return True iff N is a name that "statically denotes" an entity.
3272 function Statically_Denotes_Object
(N
: Node_Id
) return Boolean;
3273 -- Return True iff N is a name that "statically denotes" an object.
3275 function Statically_Different
(E1
, E2
: Node_Id
) return Boolean;
3276 -- Return True if it can be statically determined that the Expressions
3277 -- E1 and E2 refer to different objects
3279 function Statically_Names_Object
(N
: Node_Id
) return Boolean;
3280 -- Return True iff N is a name that "statically names" an object.
3282 function String_From_Numeric_Literal
(N
: Node_Id
) return String_Id
;
3283 -- Return the string that corresponds to the numeric literal N as it
3284 -- appears in the source.
3286 function Subject_To_Loop_Entry_Attributes
(N
: Node_Id
) return Boolean;
3287 -- Determine whether node N is a loop statement subject to at least one
3288 -- 'Loop_Entry attribute.
3290 function Subprogram_Access_Level
(Subp
: Entity_Id
) return Uint
;
3291 -- Return the accessibility level of the view denoted by Subp
3293 function Support_Atomic_Primitives
(Typ
: Entity_Id
) return Boolean;
3294 -- Return True if Typ supports the GCC built-in atomic operations (i.e. if
3295 -- Typ is properly sized and aligned).
3297 procedure Trace_Scope
(N
: Node_Id
; E
: Entity_Id
; Msg
: String);
3298 -- Print debugging information on entry to each unit being analyzed
3300 procedure Transfer_Entities
(From
: Entity_Id
; To
: Entity_Id
);
3301 -- Move a list of entities from one scope to another, and recompute
3302 -- Is_Public based upon the new scope.
3305 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
3306 Process_Itypes
: Boolean := False;
3307 function Traverse_More_Func
(Node
: Node_Id
) return Traverse_Final_Result
;
3308 -- This is a version of Atree.Traverse_Func that not only traverses
3309 -- syntactic children of nodes, but also semantic children which are
3310 -- logically children of the node. This concerns currently lists of
3311 -- action nodes and ranges under Itypes, both inserted by the compiler.
3312 -- Itypes are only traversed when Process_Itypes is True.
3315 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
3316 Process_Itypes
: Boolean := False;
3317 procedure Traverse_More_Proc
(Node
: Node_Id
);
3318 pragma Inline
(Traverse_More_Proc
);
3319 -- This is the same as Traverse_More_Func except that no result is
3320 -- returned, i.e. Traverse_More_Func is called and the result is simply
3323 function Type_Access_Level
3325 Allow_Alt_Model
: Boolean := True;
3326 Assoc_Ent
: Entity_Id
:= Empty
) return Uint
;
3327 -- Return the accessibility level of Typ
3329 -- The Allow_Alt_Model parameter allows the alternative level calculation
3330 -- under the restriction No_Dynamic_Accessibility_Checks to be performed.
3332 -- Assoc_Ent allows for the optional specification of the entity associated
3333 -- with Typ. This gets utilized mostly for anonymous access type
3334 -- processing, where context matters in interpreting Typ's level.
3336 function Type_Without_Stream_Operation
3338 Op
: TSS_Name_Type
:= TSS_Null
) return Entity_Id
;
3339 -- AI05-0161: In Ada 2012, if the restriction No_Default_Stream_Attributes
3340 -- is active then we cannot generate stream subprograms for composite types
3341 -- with elementary subcomponents that lack user-defined stream subprograms.
3342 -- This predicate determines whether a type has such an elementary
3343 -- subcomponent. If Op is TSS_Null, a type that lacks either Read or Write
3344 -- prevents the construction of a composite stream operation. If Op is
3345 -- specified we check only for the given stream operation.
3347 function Ultimate_Overlaid_Entity
(E
: Entity_Id
) return Entity_Id
;
3348 -- If entity E is overlaying some other entity via an Address clause (which
3349 -- possibly overlays yet another entity via its own Address clause), then
3350 -- return the ultimate overlaid entity. If entity E is not overlaying any
3351 -- other entity (or the overlaid entity cannot be determined statically),
3352 -- then return Empty.
3354 -- Subsidiary to the analysis of object overlays in SPARK.
3356 function Ultimate_Prefix
(N
: Node_Id
) return Node_Id
;
3357 -- Obtain the "outermost" prefix of arbitrary node N. Return N if no such
3360 function Unique_Defining_Entity
(N
: Node_Id
) return Entity_Id
;
3361 -- Return the entity that represents declaration N, so that different
3362 -- views of the same entity have the same unique defining entity:
3363 -- * private view and full view of a deferred constant
3365 -- * entry spec and entry body
3367 -- * formal parameter on spec and body
3368 -- --> formal parameter on spec
3369 -- * package spec, body, and body stub
3371 -- * protected type, protected body, and protected body stub
3372 -- --> protected type (full view if private)
3373 -- * subprogram spec, body, and body stub
3374 -- --> subprogram spec
3375 -- * task type, task body, and task body stub
3376 -- --> task type (full view if private)
3377 -- * private or incomplete view and full view of a type
3379 -- In other cases, return the defining entity for N.
3381 function Unique_Entity
(E
: Entity_Id
) return Entity_Id
;
3382 -- Return the unique entity for entity E, which would be returned by
3383 -- Unique_Defining_Entity if applied to the enclosing declaration of E.
3385 function Unique_Name
(E
: Entity_Id
) return String;
3386 -- Return a unique name for entity E, which could be used to identify E
3387 -- across compilation units.
3389 Child_Prefix
: constant String := "ada___";
3390 -- Prefix for child packages when building a unique name for an entity. It
3391 -- is included here to share between Unique_Name and gnatprove.
3393 function Unit_Is_Visible
(U
: Entity_Id
) return Boolean;
3394 -- Determine whether a compilation unit is visible in the current context,
3395 -- because there is a with_clause that makes the unit available. Used to
3396 -- provide better messages on common visiblity errors on operators.
3398 function Universal_Interpretation
(Opnd
: Node_Id
) return Entity_Id
;
3399 -- Yields Universal_Integer or Universal_Real if this is a candidate
3401 function Unqualify
(Expr
: Node_Id
) return Node_Id
;
3402 pragma Inline
(Unqualify
);
3403 -- Removes any qualifications from Expr. For example, for T1'(T2'(X)), this
3404 -- returns X. If Expr is not a qualified expression, returns Expr.
3406 function Unqual_Conv
(Expr
: Node_Id
) return Node_Id
;
3407 pragma Inline
(Unqual_Conv
);
3408 -- Similar to Unqualify, but removes qualified expressions, type
3409 -- conversions, and unchecked conversions.
3411 function Validated_View
(Typ
: Entity_Id
) return Entity_Id
;
3412 -- Obtain the "validated view" of arbitrary type Typ which is suitable for
3413 -- verification by attribute 'Valid_Scalars. This view is the type itself
3414 -- or its full view while stripping away concurrency, derivations, and
3417 function Visible_Ancestors
(Typ
: Entity_Id
) return Elist_Id
;
3418 -- [Ada 2012:AI-0125-1]: Collect all the visible parents and progenitors
3419 -- of a type extension or private extension declaration. If the full-view
3420 -- of private parents and progenitors is available then it is used to
3421 -- generate the list of visible ancestors; otherwise their partial
3422 -- view is added to the resulting list.
3424 function Within_Init_Proc
return Boolean;
3425 -- Determines if Current_Scope is within an init proc
3427 function Within_Protected_Type
(E
: Entity_Id
) return Boolean;
3428 -- Returns True if entity E is declared within a protected type
3430 function Within_Scope
(E
: Entity_Id
; S
: Entity_Id
) return Boolean;
3431 -- Returns True if entity E is declared within scope S
3433 procedure Wrong_Type
(Expr
: Node_Id
; Expected_Type
: Entity_Id
);
3434 -- Output error message for incorrectly typed expression. Expr is the node
3435 -- for the incorrectly typed construct (Etype (Expr) is the type found),
3436 -- and Expected_Type is the entity for the expected type. Note that Expr
3437 -- does not have to be a subexpression, anything with an Etype field may
3440 function Yields_Synchronized_Object
(Typ
: Entity_Id
) return Boolean;
3441 -- Determine whether type Typ "yields synchronized object" as specified by
3442 -- SPARK RM 9.1. To qualify as such, a type must be
3443 -- * An array type whose element type yields a synchronized object
3444 -- * A descendant of type Ada.Synchronous_Task_Control.Suspension_Object
3445 -- * A protected type
3446 -- * A record type or type extension without defaulted discriminants
3447 -- whose components are of a type that yields a synchronized object.
3448 -- * A synchronized interface type
3451 function Yields_Universal_Type
(N
: Node_Id
) return Boolean;
3452 -- Determine whether unanalyzed node N yields a universal type
3454 procedure Preanalyze_Without_Errors
(N
: Node_Id
);
3455 -- Preanalyze N without reporting errors
3457 package Interval_Lists
is
3458 type Discrete_Interval
is
3463 type Discrete_Interval_List
is
3464 array (Pos
range <>) of Discrete_Interval
;
3465 -- A sorted (in ascending order) list of non-empty pairwise-disjoint
3466 -- intervals, always with a gap of at least one value between
3467 -- successive intervals (i.e., mergeable intervals are merged).
3468 -- Low bound is one; high bound is nonnegative.
3470 function Aggregate_Intervals
(N
: Node_Id
) return Discrete_Interval_List
;
3471 -- Given an array aggregate N, returns the (unique) interval list
3472 -- representing the values of the aggregate choices; if all the array
3473 -- components are covered by the others choice then the length of the
3476 function Choice_List_Intervals
3477 (Discrete_Choices
: List_Id
) return Discrete_Interval_List
;
3478 -- Given a discrete choice list, returns the (unique) interval
3479 -- list representing the chosen values.
3481 function Type_Intervals
(Typ
: Entity_Id
) return Discrete_Interval_List
;
3482 -- Given a static discrete type or subtype, returns the (unique)
3483 -- interval list representing the values of the type/subtype.
3484 -- If no static predicates are involved, the length of the result
3485 -- will be at most one.
3487 function Is_Subset
(Subset
, Of_Set
: Discrete_Interval_List
)
3489 -- Returns True iff every value belonging to some interval of
3490 -- Subset also belongs to some interval of Of_Set.
3492 -- When we get around to implementing "is statically compatible"
3493 -- correctly for real types with static predicates, we may need
3494 -- an analogous Real_Interval_List type. Most of the language
3495 -- rules that reference "is statically compatible" pertain to
3496 -- discriminants and therefore do not require support for real types;
3497 -- the exception is 12.5.1(8).
3499 Intervals_Error
: exception;
3500 -- Raised when the list of non-empty pair-wise disjoint intervals cannot
3504 package Old_Attr_Util
is
3505 -- Operations related to 'Old attribute evaluation. This
3506 -- includes cases where a level of indirection is needed due to
3507 -- conditional evaluation as well as support for the
3508 -- "known on entry" rules.
3510 package Conditional_Evaluation
is
3511 function Eligible_For_Conditional_Evaluation
3512 (Expr
: Node_Id
) return Boolean;
3513 -- Given a subexpression of a Postcondition expression
3514 -- (typically a 'Old attribute reference), returns True if
3515 -- - the expression is conditionally evaluated; and
3516 -- - its determining expressions are all known on entry; and
3517 -- - Ada_Version >= Ada_2022.
3518 -- See RM 6.1.1 for definitions of these terms.
3520 -- Also returns True if Expr is of an anonymous access type;
3521 -- this is just because we want the code that knows how to build
3522 -- 'Old temps in that case to reside in only one place.
3524 function Conditional_Evaluation_Condition
3525 (Expr
: Node_Id
) return Node_Id
;
3526 -- Given an expression which is eligible for conditional evaluation,
3527 -- build a Boolean expression whose value indicates whether the
3528 -- expression should be evaluated.
3529 end Conditional_Evaluation
;
3531 package Indirect_Temps
is
3533 with procedure Append_Item
(N
: Node_Id
; Is_Eval_Stmt
: Boolean);
3534 -- If Is_Eval_Stmt is True, then N is a statement that should
3535 -- only be executed in the case where the 'Old prefix is to be
3536 -- evaluated. If Is_Eval_Stmt is False, then N is a declaration
3537 -- which should be elaborated unconditionally.
3538 -- Client is responsible for ensuring that any appended
3539 -- Eval_Stmt nodes are eventually analyzed.
3541 Append_Decls_In_Reverse_Order
: Boolean := False;
3542 -- This parameter is for the convenience of exp_prag.adb, where we
3543 -- want to Prepend rather than Append so it is better to get the
3544 -- Append calls in reverse order.
3546 procedure Declare_Indirect_Temp
3547 (Attr_Prefix
: Node_Id
; -- prefix of 'Old attribute (or similar?)
3548 Indirect_Temp
: out Entity_Id
);
3549 -- Indirect_Temp is of an access type; it is unconditionally
3550 -- declared but only conditionally initialized to reference the
3551 -- saved value of Attr_Prefix.
3553 function Indirect_Temp_Needed
(Typ
: Entity_Id
) return Boolean;
3554 -- Returns True for a specific tagged type because the temp must
3555 -- be of the class-wide type in order to preserve the underlying tag.
3557 -- Also returns True in the case of an anonymous access type
3558 -- because we want the code that knows how to deal with
3559 -- this case to reside in only one place.
3561 -- For an unconstrained-but-definite discriminated subtype, returns
3562 -- True if the potential difference in size between an
3563 -- unconstrained object and a constrained object is large.
3564 -- [This part is not implemented yet.]
3566 -- Otherwise, returns False if a declaration of the form
3568 -- is legal and side-effect-free (assuming that default
3569 -- initialization is suppressed). For example, returns True if Typ is
3570 -- indefinite, or if Typ has a controlled part.
3573 function Indirect_Temp_Value
3576 Loc
: Source_Ptr
) return Node_Id
;
3577 -- Evaluate a temp declared by Declare_Indirect_Temp.
3579 function Is_Access_Type_For_Indirect_Temp
3580 (T
: Entity_Id
) return Boolean;
3581 -- True for an access type that was declared via a call
3582 -- to Declare_Indirect_Temp.
3583 -- Indicates that the given access type should be treated
3584 -- the same with respect to finalization as a
3585 -- user-defined "comes from source" access type.
3590 package Storage_Model_Support
is
3592 -- This package provides a set of utility functions related to support
3593 -- for the Storage_Model feature. These functions provide an interface
3594 -- that the compiler (in particular back-end phases such as gigi and
3595 -- GNAT-LLVM) can use to easily obtain entities and operations that
3596 -- are specified for types in the aspects Storage_Model_Type and
3597 -- Designated_Storage_Model.
3599 function Get_Storage_Model_Type_Entity
3601 Nam
: Name_Id
) return Entity_Id
;
3602 -- Given type Typ with aspect Storage_Model_Type, returns the Entity_Id
3603 -- corresponding to the entity associated with Nam in the aspect. If the
3604 -- type does not specify the aspect, or such an entity is not present,
3605 -- then returns Empty. (Note: This function is modeled on function
3606 -- Get_Iterable_Type_Primitive.)
3608 function Has_Designated_Storage_Model_Aspect
3609 (Typ
: Entity_Id
) return Boolean;
3610 -- Returns True iff Typ specifies aspect Designated_Storage_Model
3612 function Has_Storage_Model_Type_Aspect
(Typ
: Entity_Id
) return Boolean;
3613 -- Returns True iff Typ specifies aspect Storage_Model_Type
3615 function Storage_Model_Object
(Typ
: Entity_Id
) return Entity_Id
;
3616 -- Given an access type with aspect Designated_Storage_Model, returns
3617 -- the storage-model object associated with that type; returns Empty
3618 -- if there is no associated object.
3620 function Storage_Model_Type
(Obj
: Entity_Id
) return Entity_Id
;
3621 -- Given an object Obj of a type specifying aspect Storage_Model_Type,
3622 -- returns that type; otherwise returns Empty.
3624 function Storage_Model_Address_Type
(Typ
: Entity_Id
) return Entity_Id
;
3625 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3626 -- the type specified for the Address_Type choice in that aspect;
3627 -- returns Empty if the aspect or the type isn't specified.
3629 function Storage_Model_Null_Address
(Typ
: Entity_Id
) return Entity_Id
;
3630 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3631 -- constant specified for Null_Address choice in that aspect; returns
3632 -- Empty if the aspect or the constant object isn't specified.
3634 function Storage_Model_Allocate
(Typ
: Entity_Id
) return Entity_Id
;
3635 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3636 -- procedure specified for the Allocate choice in that aspect; returns
3637 -- Empty if the aspect or the procedure isn't specified.
3639 function Storage_Model_Deallocate
(Typ
: Entity_Id
) return Entity_Id
;
3640 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3641 -- procedure specified for the Deallocate choice in that aspect; returns
3642 -- Empty if the aspect or the procedure isn't specified.
3644 function Storage_Model_Copy_From
(Typ
: Entity_Id
) return Entity_Id
;
3645 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3646 -- procedure specified for the Copy_From choice in that aspect; returns
3647 -- Empty if the aspect or the procedure isn't specified.
3649 function Storage_Model_Copy_To
(Typ
: Entity_Id
) return Entity_Id
;
3650 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3651 -- procedure specified for the Copy_To choice in that aspect; returns
3652 -- Empty if the aspect or the procedure isn't specified.
3654 function Storage_Model_Storage_Size
(Typ
: Entity_Id
) return Entity_Id
;
3655 -- Given a type Typ that specifies aspect Storage_Model_Type, returns
3656 -- function specified for Storage_Size choice in that aspect; returns
3657 -- Empty if the aspect or the procedure isn't specified.
3659 end Storage_Model_Support
;