| blob | 96a295cd218b6c56f9ca3b8eb100bd6e244776f0 |
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- S E M _ R E S --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
10 -- --
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. --
20 -- --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
23 -- --
24 ------------------------------------------------------------------------------
81 -----------------------
82 -- Local Subprograms --
83 -----------------------
85 -- Second pass (top-down) type checking and overload resolution procedures
86 -- Typ is the type required by context. These procedures propagate the
87 -- type information recursively to the descendants of N. If the node
88 -- is not overloaded, its Etype is established in the first pass. If
89 -- overloaded, the Resolve routines set the correct type. For arith.
90 -- operators, the Etype is the base type of the context.
92 -- Note that Resolve_Attribute is separated off in Sem_Attr
95 -- Enforce the restrictions on the use of discriminants when constraining
96 -- a component of a discriminated type (record or concurrent type).
99 -- Given a node for an operator associated with type T, check that
100 -- the operator is visible. Operators all of whose operands are
101 -- universal must be checked for visibility during resolution
102 -- because their type is not determinable based on their operands.
104 procedure Check_Fully_Declared_Prefix
107 -- Check that the type of the prefix of a dereference is not incomplete
110 -- Given a call node, N, which is known to occur immediately within the
111 -- subprogram being called, determines whether it is a detectable case of
112 -- an infinite recursion, and if so, outputs appropriate messages. Returns
113 -- True if an infinite recursion is detected, and False otherwise.
116 -- If the type of the object being initialized uses the secondary stack
117 -- directly or indirectly, create a transient scope for the call to the
118 -- init proc. This is because we do not create transient scopes for the
119 -- initialization of individual components within the init proc itself.
120 -- Could be optimized away perhaps?
123 -- N is the node for a logical operator. If the operator is predefined, and
124 -- the root type of the operands is Standard.Boolean, then a check is made
125 -- for restriction No_Direct_Boolean_Operators. This procedure also handles
126 -- the style check for Style_Check_Boolean_And_Or.
129 -- Determine whether E is an access type declared by an access
130 -- declaration, and not an (anonymous) allocator type.
133 -- Utility to check whether the name in the call is a predefined
134 -- operator, in which case the call is made into an operator node.
135 -- An instance of an intrinsic conversion operation may be given
136 -- an operator name, but is not treated like an operator.
139 -- If a default expression in entry call N depends on the discriminants
140 -- of the task, it must be replaced with a reference to the discriminant
141 -- of the task being called.
143 procedure Resolve_Op_Concat_Arg
148 -- Internal procedure for Resolve_Op_Concat to resolve one operand of
149 -- concatenation operator. The operand is either of the array type or of
150 -- the component type. If the operand is an aggregate, and the component
151 -- type is composite, this is ambiguous if component type has aggregates.
154 -- Does the first part of the work of Resolve_Op_Concat
157 -- Does the "rest" of the work of Resolve_Op_Concat, after the left operand
158 -- has been resolved. See Resolve_Op_Concat for details.
193 function Operator_Kind
196 -- Utility to map the name of an operator into the corresponding Node. Used
197 -- by other node rewriting procedures.
200 -- Resolve actuals of call, and add default expressions for missing ones.
201 -- N is the Node_Id for the subprogram call, and Nam is the entity of the
202 -- called subprogram.
205 -- Called from Resolve_Call, when the prefix denotes an entry or element
206 -- of entry family. Actuals are resolved as for subprograms, and the node
207 -- is rebuilt as an entry call. Also called for protected operations. Typ
208 -- is the context type, which is used when the operation is a protected
209 -- function with no arguments, and the return value is indexed.
212 -- A call to a user-defined intrinsic operator is rewritten as a call
213 -- to the corresponding predefined operator, with suitable conversions.
216 -- Ditto, for unary operators (only arithmetic ones)
219 -- If an operator node resolves to a call to a user-defined operator,
220 -- rewrite the node as a function call.
222 procedure Make_Call_Into_Operator
226 -- Inverse transformation: if an operator is given in functional notation,
227 -- then after resolving the node, transform into an operator node, so
228 -- that operands are resolved properly. Recall that predefined operators
229 -- do not have a full signature and special resolution rules apply.
231 procedure Rewrite_Renamed_Operator
235 -- An operator can rename another, e.g. in an instantiation. In that
236 -- case, the proper operator node must be constructed and resolved.
239 -- The String_Literal_Subtype is built for all strings that are not
240 -- operands of a static concatenation operation. If the argument is
241 -- not a N_String_Literal node, then the call has no effect.
244 -- Build subtype of array type, with the range specified by the slice
247 -- Called after N has been resolved and evaluated, but before range checks
248 -- have been applied. Currently simplifies a combination of floating-point
249 -- to integer conversion and Truncation attribute.
252 -- A universal_fixed expression in an universal context is unambiguous
253 -- if there is only one applicable fixed point type. Determining whether
254 -- there is only one requires a search over all visible entities, and
255 -- happens only in very pathological cases (see 6115-006).
257 function Valid_Conversion
261 -- Verify legality rules given in 4.6 (8-23). Target is the target
262 -- type of the conversion, which may be an implicit conversion of
263 -- an actual parameter to an anonymous access type (in which case
264 -- N denotes the actual parameter and N = Operand).
266 -------------------------
267 -- Ambiguous_Character --
268 -------------------------
273 begin
277 -- First the ones in Standard
279 Error_Msg_N
281 Error_Msg_N
284 -- Include Wide_Wide_Character in Ada 2005 mode
287 Error_Msg_N
291 -- Now any other types that match
301 -------------------------
302 -- Analyze_And_Resolve --
303 -------------------------
306 begin
312 begin
317 -- Version withs check(s) suppressed
319 procedure Analyze_And_Resolve
323 is
326 begin
328 declare
330 begin
336 else
337 declare
340 begin
348 and then Scope_Is_Transient
349 then
350 -- This can only happen if a transient scope was created
351 -- for an inner expression, which will be removed upon
352 -- completion of the analysis of an enclosing construct.
353 -- The transient scope must have the suppress status of
354 -- the enclosing environment, not of this Analyze call.
357 Scope_Suppress;
361 procedure Analyze_And_Resolve
364 is
367 begin
369 declare
371 begin
377 else
378 declare
381 begin
389 and then Scope_Is_Transient
390 then
392 Scope_Suppress;
396 ----------------------------
397 -- Check_Discriminant_Use --
398 ----------------------------
406 begin
407 -- Any use in a spec-expression is legal
414 -- Discriminant cannot be used to constrain a scalar type
421 then
426 -- The following check catches the unusual case where
427 -- a discriminant appears within an index constraint
428 -- that is part of a larger expression within a constraint
429 -- on a component, e.g. "C : Int range 1 .. F (new A(1 .. D))".
430 -- For now we only check case of record components, and
431 -- note that a similar check should also apply in the
432 -- case of discriminant constraints below. ???
434 -- Note that the check for N_Subtype_Declaration below is to
435 -- detect the valid use of discriminants in the constraints of a
436 -- subtype declaration when this subtype declaration appears
437 -- inside the scope of a record type (which is syntactically
438 -- illegal, but which may be created as part of derived type
439 -- processing for records). See Sem_Ch3.Build_Derived_Record_Type
440 -- for more info.
444 and then not
446 and then
448 N_Subtype_Declaration)
450 then
451 Error_Msg_N
456 -- Detect a common error:
458 -- type R (D : Positive := 100) is record
459 -- Name : String (1 .. D);
460 -- end record;
462 -- The default value causes an object of type R to be allocated
463 -- with room for Positive'Last characters. The RM does not mandate
464 -- the allocation of the maximum size, but that is what GNAT does
465 -- so we should warn the programmer that there is a problem.
474 -- Return True if type T has a large enough range that
475 -- any array whose index type covered the whole range of
476 -- the type would likely raise Storage_Error.
478 ------------------------
479 -- Large_Storage_Type --
480 ------------------------
483 begin
484 -- The type is considered large if its bounds are known at
485 -- compile time and if it requires at least as many bits as
486 -- a Positive to store the possible values.
490 and then
495 -- Start of processing for Check_Large
497 begin
498 -- Check that the Disc has a large range
504 -- If the enclosing type is limited, we allocate only the
505 -- default value, not the maximum, and there is no need for
506 -- a warning.
512 -- Check that it is the high bound
516 then
520 -- Check the array allows a large range at this bound.
521 -- First find the array
535 -- Next, find the dimension
543 loop
552 -- Now, check the dimension has a large range
558 -- Warn about the danger
560 Error_Msg_N
570 -- Legal case is in index or discriminant constraint
573 N_Discriminant_Association)
574 then
576 Error_Msg_N
581 then
582 Error_Msg_N
588 -- Otherwise, context is an expression. It should not be within
589 -- (i.e. a subexpression of) a constraint for a component.
591 else
595 N_Subtype_Indication,
596 N_Entry_Declaration)
597 loop
603 -- If the discriminant is used in an expression that is a bound
604 -- of a scalar type, an Itype is created and the bounds are attached
605 -- to its range, not to the original subtype indication. Such use
606 -- is of course a double fault.
610 N_Derived_Type_Definition)
613 -- The constraint itself may be given by a subtype indication,
614 -- rather than by a more common discrete range.
617 and then
621 then
622 Error_Msg_N
628 --------------------------------
629 -- Check_For_Visible_Operator --
630 --------------------------------
633 begin
635 Error_Msg_NE
641 ----------------------------------
642 -- Check_Fully_Declared_Prefix --
643 ----------------------------------
645 procedure Check_Fully_Declared_Prefix
648 is
649 begin
650 -- Check that the designated type of the prefix of a dereference is
651 -- not an incomplete type. This cannot be done unconditionally, because
652 -- dereferences of private types are legal in default expressions. This
653 -- case is taken care of in Check_Fully_Declared, called below. There
654 -- are also 2005 cases where it is legal for the prefix to be unfrozen.
656 -- This consideration also applies to similar checks for allocators,
657 -- qualified expressions, and type conversions.
659 -- An additional exception concerns other per-object expressions that
660 -- are not directly related to component declarations, in particular
661 -- representation pragmas for tasks. These will be per-object
662 -- expressions if they depend on discriminants or some global entity.
663 -- If the task has access discriminants, the designated type may be
664 -- incomplete at the point the expression is resolved. This resolution
665 -- takes place within the body of the initialization procedure, where
666 -- the discriminant is replaced by its discriminal.
670 then
673 -- Ada 2005 (AI-326): Tagged incomplete types allowed. The wrong usages
674 -- are handled by Analyze_Access_Attribute, Analyze_Assignment,
675 -- Analyze_Object_Renaming, and Freeze_Entity.
681 E_Incomplete_Type
683 then
685 else
690 ------------------------------
691 -- Check_Infinite_Recursion --
692 ------------------------------
699 -- Check whether list of actuals is identical to list of formals
700 -- of called function (which is also the enclosing scope).
702 ------------------------
703 -- Same_Argument_List --
704 ------------------------
711 begin
714 else
723 then
734 -- Start of processing for Check_Infinite_Recursion
736 begin
737 -- Special case, if this is a procedure call and is a call to the
738 -- current procedure with the same argument list, then this is for
739 -- sure an infinite recursion and we insert a call to raise SE.
743 and then Same_Argument_List
744 then
745 declare
747 begin
751 then
762 -- If not that special case, search up tree, quitting if we reach a
763 -- construct (e.g. a conditional) that tells us that this is not a
764 -- case for an infinite recursion warning.
767 loop
770 -- If no parent, then we were not inside a subprogram, this can for
771 -- example happen when processing certain pragmas in a spec. Just
772 -- return False in this case.
778 -- Done if we get to subprogram body, this is definitely an infinite
779 -- recursion case if we did not find anything to stop us.
783 -- If appearing in conditional, result is false
786 N_And_Then,
787 N_If_Statement,
788 N_Case_Statement)
789 then
794 then
795 -- If the call is the expression of a return statement and the
796 -- actuals are identical to the formals, it's worth a warning.
797 -- However, we skip this if there is an immediately preceding
798 -- raise statement, since the call is never executed.
800 -- Furthermore, this corresponds to a common idiom:
802 -- function F (L : Thing) return Boolean is
803 -- begin
804 -- raise Program_Error;
805 -- return F (L);
806 -- end F;
808 -- for generating a stub function
811 and then Same_Argument_List
812 then
815 -- OK, return statement is in a statement list, look for raise
817 declare
820 begin
821 -- Skip past N_Freeze_Entity nodes generated by expansion
826 loop
830 -- If no raise statement, give warning
833 and then
841 else
852 -------------------------------
853 -- Check_Initialization_Call --
854 -------------------------------
860 -- Check whether the creation of an object of the type will involve
861 -- use of the secondary stack. If T is a record type, this is true
862 -- if the expression for some component uses the secondary stack, e.g.
863 -- through a call to a function that returns an unconstrained value.
864 -- False if T is controlled, because cleanups occur elsewhere.
866 -------------
867 -- Uses_SS --
868 -------------
875 begin
876 -- Normally we want to use the underlying type, but if it's not set
877 -- then continue with T.
894 then
895 -- The expression for a dynamic component may be rewritten
896 -- as a dereference, so retrieve original node.
900 -- Return True if the expression is a call to a function
901 -- (including an attribute function such as Image) with
902 -- a result that requires a transient scope.
908 then
921 else
926 -- Start of processing for Check_Initialization_Call
928 begin
929 -- Establish a transient scope if the type needs it
936 ---------------------------------------
937 -- Check_No_Direct_Boolean_Operators --
938 ---------------------------------------
941 begin
944 then
945 -- Restriction only applies to original source code
957 ------------------------------
958 -- Check_Parameterless_Call --
959 ------------------------------
965 -- If the prefix is of an access_to_subprogram type, the node must be
966 -- rewritten as a call. Ditto if the prefix is overloaded and all its
967 -- interpretations are access to subprograms.
969 ---------------------------
970 -- Prefix_Is_Access_Subp --
971 ---------------------------
977 begin
979 return
982 else
987 then
998 -- Start of processing for Check_Parameterless_Call
1000 begin
1001 -- Defend against junk stuff if errors already detected
1008 then
1015 -- If the context expects a value, and the name is a procedure, this is
1016 -- most likely a missing 'Access. Don't try to resolve the parameterless
1017 -- call, error will be caught when the outer call is analyzed.
1022 and then
1024 N_Function_Call,
1025 N_Procedure_Call_Statement)
1026 then
1030 -- Rewrite as call if overloadable entity that is (or could be, in the
1031 -- overloaded case) a function call. If we know for sure that the entity
1032 -- is an enumeration literal, we do not rewrite it.
1039 -- Rewrite as call if it is an explicit dereference of an expression of
1040 -- a subprogram access type, and the subprogram type is not that of a
1041 -- procedure or entry.
1043 or else
1046 -- Rewrite as call if it is a selected component which is a function,
1047 -- this is the case of a call to a protected function (which may be
1048 -- overloaded with other protected operations).
1050 or else
1053 or else
1055 or else
1059 -- If one of the above three conditions is met, rewrite as call.
1060 -- Apply the rewriting only once.
1062 then
1065 then
1068 -- If overloaded, overload set belongs to new copy
1072 -- Change node to parameterless function call (note that the
1073 -- Parameter_Associations associations field is left set to Empty,
1074 -- its normal default value since there are no parameters)
1087 -----------------------------
1088 -- Is_Definite_Access_Type --
1089 -----------------------------
1093 begin
1099 ----------------------
1100 -- Is_Predefined_Op --
1101 ----------------------
1104 begin
1112 -----------------------------
1113 -- Make_Call_Into_Operator --
1114 -----------------------------
1116 procedure Make_Call_Into_Operator
1120 is
1135 -- If the operand is not universal, and the operator is given by a
1136 -- expanded name, verify that the operand has an interpretation with
1137 -- a type defined in the given scope of the operator.
1140 -- Find a type of the given class in the package Pack that contains
1141 -- the operator.
1143 ---------------------------
1144 -- Operand_Type_In_Scope --
1145 ---------------------------
1152 begin
1156 else
1170 ---------------
1171 -- Type_In_P --
1172 ---------------
1178 -- Verify that node is not part of the type declaration for the
1179 -- candidate type, which would otherwise be invisible.
1181 -------------
1182 -- In_Decl --
1183 -------------
1189 begin
1198 else
1201 loop
1204 else
1213 -- Start of processing for Type_In_P
1215 begin
1216 -- If the context type is declared in the prefix package, this
1217 -- is the desired base type.
1221 then
1224 else
1228 and then not In_Decl
1229 then
1240 -- Start of processing for Make_Call_Into_Operator
1242 begin
1245 -- Binary operator
1255 -- Unary operator
1257 else
1263 -- If the operator is denoted by an expanded name, and the prefix is
1264 -- not Standard, but the operator is a predefined one whose scope is
1265 -- Standard, then this is an implicit_operator, inserted as an
1266 -- interpretation by the procedure of the same name. This procedure
1267 -- overestimates the presence of implicit operators, because it does
1268 -- not examine the type of the operands. Verify now that the operand
1269 -- type appears in the given scope. If right operand is universal,
1270 -- check the other operand. In the case of concatenation, either
1271 -- argument can be the component type, so check the type of the result.
1272 -- If both arguments are literals, look for a type of the right kind
1273 -- defined in the given scope. This elaborate nonsense is brought to
1274 -- you courtesy of b33302a. The type itself must be frozen, so we must
1275 -- find the type of the proper class in the given scope.
1277 -- A final wrinkle is the multiplication operator for fixed point
1278 -- types, which is defined in Standard only, and not in the scope of
1279 -- the fixed_point type itself.
1284 -- If the entity being called is defined in the given package,
1285 -- it is a renaming of a predefined operator, and known to be
1286 -- legal.
1290 then
1293 -- Visibility does not need to be checked in an instance: if the
1294 -- operator was not visible in the generic it has been diagnosed
1295 -- already, else there is an implicit copy of it in the instance.
1304 then
1309 -- Ada 2005, AI-420: Predefined equality on Universal_Access
1310 -- is available.
1315 then
1318 else
1327 and then Is_Binary
1329 then
1335 -- Verify that the scope contains a type that corresponds to
1336 -- the given literal. Optimize the case where Pack is Standard.
1358 else
1367 else
1376 then
1379 -- If the type is defined elsewhere, and the operator is not
1380 -- defined in the given scope (by a renaming declaration, e.g.)
1381 -- then this is an error as well. If an extension of System is
1382 -- present, and the type may be defined there, Pack must be
1383 -- System itself.
1390 then
1393 else
1399 then
1406 Error_Msg_NE
1417 else
1421 -- If this is a call to a function that renames a predefined equality,
1422 -- the renaming declaration provides a type that must be used to
1423 -- resolve the operands. This must be done now because resolution of
1424 -- the equality node will not resolve any remaining ambiguity, and it
1425 -- assumes that the first operand is not overloaded.
1430 then
1438 -- Do rewrite setting Comes_From_Source on the result if the original
1439 -- call came from source. Although it is not strictly the case that the
1440 -- operator as such comes from the source, logically it corresponds
1441 -- exactly to the function call in the source, so it should be marked
1442 -- this way (e.g. to make sure that validity checks work fine).
1444 declare
1446 begin
1451 -- If this is an arithmetic operator and the result type is private,
1452 -- the operands and the result must be wrapped in conversion to
1453 -- expose the underlying numeric type and expand the proper checks,
1454 -- e.g. on division.
1458 when N_Op_Add | N_Op_Subtract | N_Op_Multiply | N_Op_Divide |
1459 N_Op_Expon | N_Op_Mod | N_Op_Rem =>
1468 else
1472 -- For predefined operators on literals, the operation freezes
1473 -- their type.
1481 -------------------
1482 -- Operator_Kind --
1483 -------------------
1485 function Operator_Kind
1488 is
1491 begin
1527 else
1531 -- Unary operators
1533 else
1542 else
1550 ----------------------------
1551 -- Preanalyze_And_Resolve --
1552 ----------------------------
1557 begin
1561 -- We suppress all checks for this analysis, since the checks will
1562 -- be applied properly, and in the right location, when the default
1563 -- expression is reanalyzed and reexpanded later on.
1567 Expander_Mode_Restore;
1571 -- Version without context type
1576 begin
1583 Expander_Mode_Restore;
1587 ----------------------------------
1588 -- Replace_Actual_Discriminants --
1589 ----------------------------------
1597 -------------------
1598 -- Process_Discr --
1599 -------------------
1604 begin
1610 then
1626 -- Start of processing for Replace_Actual_Discriminants
1628 begin
1642 else
1647 -------------
1648 -- Resolve --
1649 -------------
1665 -- Determine whether a node comes from a predefined library unit or
1666 -- Standard.
1669 -- Try and fix up a literal so that it matches its expected type. New
1670 -- literals are manufactured if necessary to avoid cascaded errors.
1673 -- Called when attempt at resolving current expression fails
1675 ------------------------------------
1676 -- Comes_From_Predefined_Lib_Unit --
1677 -------------------------------------
1680 begin
1681 return
1687 --------------------
1688 -- Patch_Up_Value --
1689 --------------------
1692 begin
1695 then
1704 then
1713 then
1718 Char_Literal_Value =>
1725 then
1736 -----------------------
1737 -- Resolution_Failed --
1738 -----------------------
1741 begin
1747 -- The caller will return without calling the expander, so we need
1748 -- to set the analyzed flag. Note that it is fine to set Analyzed
1749 -- to True even if we are in the middle of a shallow analysis,
1750 -- (see the spec of sem for more details) since this is an error
1751 -- situation anyway, and there is no point in repeating the
1752 -- analysis later (indeed it won't work to repeat it later, since
1753 -- we haven't got a clear resolution of which entity is being
1754 -- referenced.)
1760 -- Start of processing for Resolve
1762 begin
1767 -- Access attribute on remote subprogram cannot be used for
1768 -- a non-remote access-to-subprogram type.
1779 then
1780 Error_Msg_N
1786 -- If the context is a Remote_Access_To_Subprogram, access attributes
1787 -- must be resolved with the corresponding fat pointer. There is no need
1788 -- to check for the attribute name since the return type of an
1789 -- attribute is never a remote type.
1795 then
1796 declare
1804 begin
1805 -- Check that Typ is a remote access-to-subprogram type
1808 -- Prefix (N) must statically denote a remote subprogram
1809 -- declared in a package specification.
1826 or else
1828 then
1830 Error_Msg_N
1832 N);
1836 -- If we are generating code for a distributed program.
1837 -- perform semantic checks against the corresponding
1838 -- remote entities.
1843 and then Expander_Active
1845 then
1846 Check_Subtype_Conformant
1848 Old_Id => Designated_Type
1869 then
1874 -- Return if already analyzed
1880 -- Return if type = Any_Type (previous error encountered)
1889 -- If not overloaded, then we know the type, and all that needs doing
1890 -- is to check that this type is compatible with the context.
1896 -- In the overloaded case, we must select the interpretation that
1897 -- is compatible with the context (i.e. the type passed to Resolve)
1899 else
1900 -- Loop through possible interpretations
1905 -- We are only interested in interpretations that are compatible
1906 -- with the expected type, any other interpretations are ignored.
1911 Write_Eol;
1914 else
1915 -- Skip the current interpretation if it is disabled by an
1916 -- abstract operator. This action is performed only when the
1917 -- type against which we are resolving is the same as the
1918 -- type of the interpretation.
1925 then
1929 -- First matching interpretation
1937 -- Matching interpretation that is not the first, maybe an
1938 -- error, but there are some cases where preference rules are
1939 -- used to choose between the two possibilities. These and
1940 -- some more obscure cases are handled in Disambiguate.
1942 else
1943 -- If the current statement is part of a predefined library
1944 -- unit, then all interpretations which come from user level
1945 -- packages should not be considered.
1947 if From_Lib
1949 then
1956 -- Disambiguation has succeeded. Skip the remaining
1957 -- interpretations.
1967 else
1968 -- Before we issue an ambiguity complaint, check for
1969 -- the case of a subprogram call where at least one
1970 -- of the arguments is Any_Type, and if so, suppress
1971 -- the message, since it is a cascaded error.
1974 N_Procedure_Call_Statement)
1975 then
1976 declare
1980 begin
1992 Write_Eol;
2005 then
2010 then
2014 -- Not that special case, so issue message using the
2015 -- flag Ambiguous to control printing of the header
2016 -- message only at the start of an ambiguous set.
2021 then
2022 Error_Msg_N
2025 else
2026 Error_Msg_NE -- CODEFIX
2034 Error_Msg_N
2036 else
2037 Error_Msg_N -- CODEFIX
2044 -- By default, the error message refers to the candidate
2045 -- interpretation. But if it is a predefined operator, it
2046 -- is implicitly declared at the declaration of the type
2047 -- of the operand. Recover the sloc of that declaration
2048 -- for the error message.
2054 Standard_Standard
2055 then
2060 then
2068 Standard_Standard
2069 then
2074 then
2078 -- If this is an indirect call, use the subprogram_type
2079 -- in the message, to have a meaningful location.
2080 -- Indicate as well if this is an inherited operation,
2081 -- created by a type declaration.
2086 then
2088 Error_Msg_Sloc :=
2090 else
2097 then
2098 -- Special-case the message for universal_fixed
2099 -- operators, which are not declared with the type
2100 -- of the operand, but appear forever in Standard.
2104 then
2105 Error_Msg_N
2109 else
2110 Error_Msg_N
2114 elsif
2116 then
2117 Error_Msg_N
2119 else
2120 Error_Msg_N -- CODEFIX
2127 -- We have a matching interpretation, Expr_Type is the type
2128 -- from this interpretation, and Seen is the entity.
2130 -- For an operator, just set the entity name. The type will be
2131 -- set by the specific operator resolution routine.
2143 -- For an explicit dereference, attribute reference, range,
2144 -- short-circuit form (which is not an operator node), or call
2145 -- with a name that is an explicit dereference, there is
2146 -- nothing to be done at this point.
2149 N_Attribute_Reference,
2150 N_And_Then,
2151 N_Indexed_Component,
2152 N_Or_Else,
2153 N_Range,
2154 N_Selected_Component,
2155 N_Slice)
2157 then
2160 -- For procedure or function calls, set the type of the name,
2161 -- and also the entity pointer for the prefix
2166 then
2173 then
2178 -- For all other cases, just set the type of the Name
2180 else
2188 -- Move to next interpretation
2196 -- At this stage Found indicates whether or not an acceptable
2197 -- interpretation exists. If not, then we have an error, except
2198 -- that if the context is Any_Type as a result of some other error,
2199 -- then we suppress the error report.
2204 -- If type we are looking for is Void, then this is the procedure
2205 -- call case, and the error is simply that what we gave is not a
2206 -- procedure name (we think of procedure calls as expressions with
2207 -- types internally, but the user doesn't think of them this way!)
2211 -- Special case message if function used as a procedure
2216 then
2217 Error_Msg_NE
2221 -- Otherwise give general message (not clear what cases this
2222 -- covers, but no harm in providing for them!)
2224 else
2230 -- Otherwise we do have a subexpression with the wrong type
2232 -- Check for the case of an allocator which uses an access type
2233 -- instead of the designated type. This is a common error and we
2234 -- specialize the message, posting an error on the operand of the
2235 -- allocator, complaining that we expected the designated type of
2236 -- the allocator.
2242 then
2246 -- Check for view mismatch on Null in instances, for which the
2247 -- view-swapping mechanism has no identifier.
2253 then
2258 -- Check for an aggregate. Sometimes we can get bogus aggregates
2259 -- from misuse of parentheses, and we are about to complain about
2260 -- the aggregate without even looking inside it.
2262 -- Instead, if we have an aggregate of type Any_Composite, then
2263 -- analyze and resolve the component fields, and then only issue
2264 -- another message if we get no errors doing this (otherwise
2265 -- assume that the errors in the aggregate caused the problem).
2269 then
2270 -- Disable expansion in any case. If there is a type mismatch
2271 -- it may be fatal to try to expand the aggregate. The flag
2272 -- would otherwise be set to false when the error is posted.
2276 declare
2278 -- Check one aggregate, and set Found to True if we have a
2279 -- definite error in any of its elements
2282 -- Check one element of aggregate and set Found to True if
2283 -- we definitely have an error in the element.
2285 ----------------
2286 -- Check_Aggr --
2287 ----------------
2292 begin
2305 -- If this is a default-initialized component, then
2306 -- there is nothing to check. The box will be
2307 -- replaced by the appropriate call during late
2308 -- expansion.
2319 ----------------
2320 -- Check_Elmt --
2321 ----------------
2324 begin
2325 -- If we have a nested aggregate, go inside it (to
2326 -- attempt a naked analyze-resolve of the aggregate
2327 -- can cause undesirable cascaded errors). Do not
2328 -- resolve expression if it needs a type from context,
2329 -- as for integer * fixed expression.
2334 else
2339 then
2349 begin
2354 -- If an error message was issued already, Found got reset
2355 -- to True, so if it is still False, issue the standard
2356 -- Wrong_Type message.
2361 then
2362 declare
2364 begin
2370 -- Protected operation: retrieve operation name
2373 else
2383 declare
2387 begin
2394 Error_Msg_NE
2400 else
2403 else
2409 Resolution_Failed;
2412 -- Test if we have more than one interpretation for the context
2415 Resolution_Failed;
2418 -- Here we have an acceptable interpretation for the context
2420 else
2421 -- Propagate type information and normalize tree for various
2422 -- predefined operations. If the context only imposes a class of
2423 -- types, rather than a specific type, propagate the actual type
2424 -- downward.
2431 then
2434 -- Any_Fixed is legal in a real context only if a specific
2435 -- fixed point type is imposed. If Norman Cohen can be
2436 -- confused by this, it deserves a separate message.
2440 then
2447 -- A user-defined operator is transformed into a function call at
2448 -- this point, so that further processing knows that operators are
2449 -- really operators (i.e. are predefined operators). User-defined
2450 -- operators that are intrinsic are just renamings of the predefined
2451 -- ones, and need not be turned into calls either, but if they rename
2452 -- a different operator, we must transform the node accordingly.
2453 -- Instantiations of Unchecked_Conversion are intrinsic but are
2454 -- treated as functions, even if given an operator designator.
2459 then
2465 and then
2467 N_Subprogram_Renaming_Declaration
2468 then
2471 -- If the node is rewritten, it will be fully resolved in
2472 -- Rewrite_Renamed_Operator.
2482 when N_Aggregate => Resolve_Aggregate (N, Ctx_Type);
2484 when N_Allocator => Resolve_Allocator (N, Ctx_Type);
2486 when N_Short_Circuit
2487 => Resolve_Short_Circuit (N, Ctx_Type);
2489 when N_Attribute_Reference
2490 => Resolve_Attribute (N, Ctx_Type);
2492 when N_Character_Literal
2493 => Resolve_Character_Literal (N, Ctx_Type);
2495 when N_Conditional_Expression
2496 => Resolve_Conditional_Expression (N, Ctx_Type);
2498 when N_Expanded_Name
2499 => Resolve_Entity_Name (N, Ctx_Type);
2501 when N_Extension_Aggregate
2502 => Resolve_Extension_Aggregate (N, Ctx_Type);
2504 when N_Explicit_Dereference
2505 => Resolve_Explicit_Dereference (N, Ctx_Type);
2507 when N_Function_Call
2508 => Resolve_Call (N, Ctx_Type);
2510 when N_Identifier
2511 => Resolve_Entity_Name (N, Ctx_Type);
2513 when N_Indexed_Component
2514 => Resolve_Indexed_Component (N, Ctx_Type);
2516 when N_Integer_Literal
2517 => Resolve_Integer_Literal (N, Ctx_Type);
2519 when N_Membership_Test
2520 => Resolve_Membership_Op (N, Ctx_Type);
2522 when N_Null => Resolve_Null (N, Ctx_Type);
2524 when N_Op_And | N_Op_Or | N_Op_Xor
2525 => Resolve_Logical_Op (N, Ctx_Type);
2527 when N_Op_Eq | N_Op_Ne
2528 => Resolve_Equality_Op (N, Ctx_Type);
2530 when N_Op_Lt | N_Op_Le | N_Op_Gt | N_Op_Ge
2531 => Resolve_Comparison_Op (N, Ctx_Type);
2533 when N_Op_Not => Resolve_Op_Not (N, Ctx_Type);
2535 when N_Op_Add | N_Op_Subtract | N_Op_Multiply |
2536 N_Op_Divide | N_Op_Mod | N_Op_Rem
2538 => Resolve_Arithmetic_Op (N, Ctx_Type);
2540 when N_Op_Concat => Resolve_Op_Concat (N, Ctx_Type);
2542 when N_Op_Expon => Resolve_Op_Expon (N, Ctx_Type);
2544 when N_Op_Plus | N_Op_Minus | N_Op_Abs
2545 => Resolve_Unary_Op (N, Ctx_Type);
2547 when N_Op_Shift => Resolve_Shift (N, Ctx_Type);
2549 when N_Procedure_Call_Statement
2550 => Resolve_Call (N, Ctx_Type);
2552 when N_Operator_Symbol
2553 => Resolve_Operator_Symbol (N, Ctx_Type);
2555 when N_Qualified_Expression
2556 => Resolve_Qualified_Expression (N, Ctx_Type);
2558 when N_Raise_xxx_Error
2559 => Set_Etype (N, Ctx_Type);
2561 when N_Range => Resolve_Range (N, Ctx_Type);
2563 when N_Real_Literal
2564 => Resolve_Real_Literal (N, Ctx_Type);
2566 when N_Reference => Resolve_Reference (N, Ctx_Type);
2568 when N_Selected_Component
2569 => Resolve_Selected_Component (N, Ctx_Type);
2571 when N_Slice => Resolve_Slice (N, Ctx_Type);
2573 when N_String_Literal
2574 => Resolve_String_Literal (N, Ctx_Type);
2576 when N_Subprogram_Info
2577 => Resolve_Subprogram_Info (N, Ctx_Type);
2579 when N_Type_Conversion
2580 => Resolve_Type_Conversion (N, Ctx_Type);
2582 when N_Unchecked_Expression =>
2583 Resolve_Unchecked_Expression (N, Ctx_Type);
2585 when N_Unchecked_Type_Conversion =>
2586 Resolve_Unchecked_Type_Conversion (N, Ctx_Type);
2588 end case;
2590 -- If the subexpression was replaced by a non-subexpression, then
2591 -- all we do is to expand it. The only legitimate case we know of
2592 -- is converting procedure call statement to entry call statements,
2593 -- but there may be others, so we are making this test general.
2595 if Nkind (N) not in N_Subexpr then
2596 Debug_A_Exit ("resolving ", N, " (done)");
2597 Expand (N);
2598 return;
2599 end if;
2601 -- The expression is definitely NOT overloaded at this point, so
2602 -- we reset the Is_Overloaded flag to avoid any confusion when
2603 -- reanalyzing the node.
2605 Set_Is_Overloaded (N, False);
2607 -- Freeze expression type, entity if it is a name, and designated
2608 -- type if it is an allocator (RM 13.14(10,11,13)).
2610 -- Now that the resolution of the type of the node is complete,
2611 -- and we did not detect an error, we can expand this node. We
2612 -- skip the expand call if we are in a default expression, see
2613 -- section "Handling of Default Expressions" in Sem spec.
2615 Debug_A_Exit ("resolving ", N, " (done)");
2617 -- We unconditionally freeze the expression, even if we are in
2618 -- default expression mode (the Freeze_Expression routine tests
2619 -- this flag and only freezes static types if it is set).
2621 Freeze_Expression (N);
2623 -- Now we can do the expansion
2625 Expand (N);
2626 end if;
2627 end Resolve;
2629 -------------
2630 -- Resolve --
2631 -------------
2633 -- Version with check(s) suppressed
2635 procedure Resolve (N : Node_Id; Typ : Entity_Id; Suppress : Check_Id) is
2636 begin
2637 if Suppress = All_Checks then
2638 declare
2639 Svg : constant Suppress_Array := Scope_Suppress;
2640 begin
2641 Scope_Suppress := (others => True);
2642 Resolve (N, Typ);
2643 Scope_Suppress := Svg;
2644 end;
2646 else
2647 declare
2648 Svg : constant Boolean := Scope_Suppress (Suppress);
2649 begin
2650 Scope_Suppress (Suppress) := True;
2651 Resolve (N, Typ);
2652 Scope_Suppress (Suppress) := Svg;
2653 end;
2654 end if;
2655 end Resolve;
2657 -------------
2658 -- Resolve --
2659 -------------
2661 -- Version with implicit type
2663 procedure Resolve (N : Node_Id) is
2664 begin
2665 Resolve (N, Etype (N));
2666 end Resolve;
2668 ---------------------
2669 -- Resolve_Actuals --
2670 ---------------------
2672 procedure Resolve_Actuals (N : Node_Id; Nam : Entity_Id) is
2673 Loc : constant Source_Ptr := Sloc (N);
2674 A : Node_Id;
2675 F : Entity_Id;
2676 A_Typ : Entity_Id;
2677 F_Typ : Entity_Id;
2678 Prev : Node_Id := Empty;
2679 Orig_A : Node_Id;
2681 procedure Check_Argument_Order;
2682 -- Performs a check for the case where the actuals are all simple
2683 -- identifiers that correspond to the formal names, but in the wrong
2684 -- order, which is considered suspicious and cause for a warning.
2686 procedure Check_Prefixed_Call;
2687 -- If the original node is an overloaded call in prefix notation,
2689 -- Try_Object_Operation has already verified that there is a valid
2690 -- interpretation, but the form of the actual can only be determined
2691 -- once the primitive operation is identified.
2694 -- If the actual is missing in a call, insert in the actuals list
2695 -- an instance of the default expression. The insertion is always
2696 -- a named association.
2699 -- Check whether T1 and T2, or their full views, are derived from a
2700 -- common type. Used to enforce the restrictions on array conversions
2701 -- of AI95-00246.
2704 -- Predicate to determine whether an actual that is a concatenation
2705 -- will be evaluated statically and does not need a transient scope.
2706 -- This must be determined before the actual is resolved and expanded
2707 -- because if needed the transient scope must be introduced earlier.
2709 --------------------------
2710 -- Check_Argument_Order --
2711 --------------------------
2714 begin
2715 -- Nothing to do if no parameters, or original node is neither a
2716 -- function call nor a procedure call statement (happens in the
2717 -- operator-transformed-to-function call case), or the call does
2718 -- not come from source, or this warning is off.
2720 if not Warn_On_Parameter_Order
2721 or else
2723 or else
2725 N_Function_Call)
2726 or else
2728 then
2732 declare
2735 begin
2736 -- Nothing to do if only one parameter
2742 -- Here if at least two arguments
2744 declare
2750 -- Set True if an out of order case is found
2752 begin
2753 -- Collect identifier names of actuals, fail if any actual is
2754 -- not a simple identifier, and record max length of name.
2760 else
2766 -- If we got this far, all actuals are identifiers and the list
2767 -- of their names is stored in the Actuals array.
2772 -- If we ran out of formals, that's odd, probably an error
2773 -- which will be detected elsewhere, but abandon the search.
2779 -- If name matches and is in order OK
2784 else
2785 -- If no match, see if it is elsewhere in list and if so
2786 -- flag potential wrong order if type is compatible.
2790 and then
2792 then
2798 -- No match
2806 -- If Formals left over, also probably an error, skip warning
2812 -- Here we give the warning if something was out of order
2815 Error_Msg_N
2822 -------------------------
2823 -- Check_Prefixed_Call --
2824 -------------------------
2833 begin
2834 -- Check whether the call is a prefixed call, with or without
2835 -- additional actuals.
2838 or else
2844 then
2847 then
2848 -- Introduce dereference on object in prefix
2850 New_A :=
2858 then
2859 -- Introduce an implicit 'Access in prefix
2862 Error_Msg_NE
2878 --------------------
2879 -- Insert_Default --
2880 --------------------
2886 begin
2887 -- Missing argument in call, nothing to insert
2892 else
2893 -- Note that we do a full New_Copy_Tree, so that any associated
2894 -- Itypes are properly copied. This may not be needed any more,
2895 -- but it does no harm as a safety measure! Defaults of a generic
2896 -- formal may be out of bounds of the corresponding actual (see
2897 -- cc1311b) and an additional check may be required.
2899 Actval :=
2900 New_Copy_Tree
2907 then
2913 then
2916 then
2917 -- If default is a real literal, do not introduce a
2918 -- conversion whose effect may depend on the run-time
2919 -- size of universal real.
2923 else
2934 -- Resolve aggregates with their base type, to avoid scope
2935 -- anomalies: the subtype was first built in the subprogram
2936 -- declaration, and the current call may be nested.
2940 else
2944 else
2947 -- See note above concerning aggregates
2951 then
2954 -- Resolve entities with their own type, which may differ
2955 -- from the type of a reference in a generic context (the
2956 -- view swapping mechanism did not anticipate the re-analysis
2957 -- of default values in calls).
2962 else
2967 -- If default is a tag indeterminate function call, propagate
2968 -- tag to obtain proper dispatching.
2972 then
2978 -- If the default expression raises constraint error, then just
2979 -- silently replace it with an N_Raise_Constraint_Error node,
2980 -- since we already gave the warning on the subprogram spec.
2990 Assoc :=
2995 -- Case of insertion is first named actual
2999 then
3006 else
3010 else
3014 -- Case of insertion is not first named actual
3016 else
3017 Set_Next_Named_Actual
3029 -------------------
3030 -- Same_Ancestor --
3031 -------------------
3037 begin
3040 then
3046 then
3053 --------------------------
3054 -- Static_Concatenation --
3055 --------------------------
3058 begin
3065 -- Concatenation is static when both operands are static
3066 -- and the concatenation operator is a predefined one.
3069 and then
3071 and then
3076 declare
3078 begin
3081 and then
3085 else
3091 -- Start of processing for Resolve_Actuals
3093 begin
3094 Check_Argument_Order;
3097 Check_Prefixed_Call;
3106 -- If we have an error in any actual or formal, indicated by a type
3107 -- of Any_Type, then abandon resolution attempt, and set result type
3108 -- to Any_Type.
3112 then
3117 -- Case where actual is present
3119 -- If the actual is an entity, generate a reference to it now. We
3120 -- do this before the actual is resolved, because a formal of some
3121 -- protected subprogram, or a task discriminant, will be rewritten
3122 -- during expansion, and the reference to the source entity may
3123 -- be lost.
3128 then
3134 then
3144 or else
3146 then
3147 -- If style checking mode on, check match of formal name
3155 -- If the formal is Out or In_Out, do not resolve and expand the
3156 -- conversion, because it is subsequently expanded into explicit
3157 -- temporaries and assignments. However, the object of the
3158 -- conversion can be resolved. An exception is the case of tagged
3159 -- type conversion with a class-wide actual. In that case we want
3160 -- the tag check to occur and no temporary will be needed (no
3161 -- representation change can occur) and the parameter is passed by
3162 -- reference, so we go ahead and resolve the type conversion.
3163 -- Another exception is the case of reference to component or
3164 -- subcomponent of a bit-packed array, in which case we want to
3165 -- defer expansion to the point the in and out assignments are
3166 -- performed.
3171 then
3174 then
3177 then
3179 -- In a view conversion, the conversion must be legal in
3180 -- both directions, and thus both component types must be
3181 -- aliased, or neither (4.6 (8)).
3183 -- The additional rule 4.6 (24.9.2) seems unduly
3184 -- restrictive: the privacy requirement should not apply
3185 -- to generic types, and should be checked in an
3186 -- instance. ARG query is in order ???
3188 Error_Msg_N
3192 elsif
3194 then
3197 then
3198 Error_Msg_N
3201 else
3202 declare
3204 Component_Type
3206 begin
3209 and then
3214 then
3215 Error_Msg_N
3229 then
3233 -- If the actual is a function call that returns a limited
3234 -- unconstrained object that needs finalization, create a
3235 -- transient scope for it, so that it can receive the proper
3236 -- finalization list.
3241 and then Expander_Active
3242 and then
3244 then
3247 -- A small optimization: if one of the actuals is a concatenation
3248 -- create a block around a procedure call to recover stack space.
3249 -- This alleviates stack usage when several procedure calls in
3250 -- the same statement list use concatenation. We do not perform
3251 -- this wrapping for code statements, where the argument is a
3252 -- static string, and we want to preserve warnings involving
3253 -- sequences of such statements.
3257 and then Expander_Active
3258 and then
3262 then
3266 else
3270 and then
3273 then
3274 Error_Msg_N
3287 -- (Ada 2005: AI-251): If the actual is an allocator whose
3288 -- directly designated type is a class-wide interface, we build
3289 -- an anonymous access type to use it as the type of the
3290 -- allocator. Later, when the subprogram call is expanded, if
3291 -- the interface has a secondary dispatch table the expander
3292 -- will add a type conversion to force the correct displacement
3293 -- of the pointer.
3296 declare
3302 begin
3305 then
3313 -- Ada 2005, AI-162:If the actual is an allocator, the
3314 -- innermost enclosing statement is the master of the
3315 -- created object. This needs to be done with expansion
3316 -- enabled only, otherwise the transient scope will not
3317 -- be removed in the expansion of the wrapped construct.
3320 and then Expander_Active
3321 then
3327 -- (Ada 2005): The call may be to a primitive operation of
3328 -- a tagged synchronized type, declared outside of the type.
3329 -- In this case the controlling actual must be converted to
3330 -- its corresponding record type, which is the formal type.
3331 -- The actual may be a subtype, either because of a constraint
3332 -- or because it is a generic actual, so use base type to
3333 -- locate concurrent type.
3338 declare
3341 begin
3344 else
3348 -- Tagged synchronized type (case 1): the actual is a
3349 -- concurrent type
3353 then
3355 Unchecked_Convert_To
3359 -- Tagged synchronized type (case 2): the formal is a
3360 -- concurrent type
3363 and then Present
3368 then
3371 -- Common case
3373 else
3382 -- For mode IN, if actual is an entity, and the type of the formal
3383 -- has warnings suppressed, then we reset Never_Set_In_Source for
3384 -- the calling entity. The reason for this is to catch cases like
3385 -- GNAT.Spitbol.Patterns.Vstring_Var where the called subprogram
3386 -- uses trickery to modify an IN parameter.
3393 then
3397 -- Perform error checks for IN and IN OUT parameters
3401 -- Check unset reference. For scalar parameters, it is clearly
3402 -- wrong to pass an uninitialized value as either an IN or
3403 -- IN-OUT parameter. For composites, it is also clearly an
3404 -- error to pass a completely uninitialized value as an IN
3405 -- parameter, but the case of IN OUT is trickier. We prefer
3406 -- not to give a warning here. For example, suppose there is
3407 -- a routine that sets some component of a record to False.
3408 -- It is perfectly reasonable to make this IN-OUT and allow
3409 -- either initialized or uninitialized records to be passed
3410 -- in this case.
3412 -- For partially initialized composite values, we also avoid
3413 -- warnings, since it is quite likely that we are passing a
3414 -- partially initialized value and only the initialized fields
3415 -- will in fact be read in the subprogram.
3420 then
3424 -- In Ada 83 we cannot pass an OUT parameter as an IN or IN OUT
3425 -- actual to a nested call, since this is case of reading an
3426 -- out parameter, which is not allowed.
3431 then
3436 -- Case of OUT or IN OUT parameter
3440 -- For an Out parameter, check for useless assignment. Note
3441 -- that we can't set Last_Assignment this early, because we may
3442 -- kill current values in Resolve_Call, and that call would
3443 -- clobber the Last_Assignment field.
3445 -- Note: call Warn_On_Useless_Assignment before doing the check
3446 -- below for Is_OK_Variable_For_Out_Formal so that the setting
3447 -- of Referenced_As_LHS/Referenced_As_Out_Formal properly
3448 -- reflects the last assignment, not this one!
3455 then
3460 -- Validate the form of the actual. Note that the call to
3461 -- Is_OK_Variable_For_Out_Formal generates the required
3462 -- reference in this case.
3468 -- What's the following about???
3472 else
3473 Kill_All_Checks;
3482 -- Apply appropriate range checks for in, out, and in-out
3483 -- parameters. Out and in-out parameters also need a separate
3484 -- check, if there is a type conversion, to make sure the return
3485 -- value meets the constraints of the variable before the
3486 -- conversion.
3488 -- Gigi looks at the check flag and uses the appropriate types.
3489 -- For now since one flag is used there is an optimization which
3490 -- might not be done in the In Out case since Gigi does not do
3491 -- any analysis. More thought required about this ???
3495 then
3507 then
3513 then
3519 then
3522 else
3526 -- Ada 2005 (AI-231)
3532 then
3533 Apply_Compile_Time_Constraint_Error
3543 then
3546 Apply_Scalar_Range_Check
3548 else
3549 Apply_Range_Check
3553 else
3559 then
3562 else
3568 -- An actual associated with an access parameter is implicitly
3569 -- converted to the anonymous access type of the formal and must
3570 -- satisfy the legality checks for access conversions.
3574 Error_Msg_N
3579 -- Check bad case of atomic/volatile argument (RM C.6(12))
3583 then
3586 then
3587 Error_Msg_N
3589 N);
3593 then
3594 Error_Msg_N
3596 N);
3600 -- Check that subprograms don't have improper controlling
3601 -- arguments (RM 3.9.2 (9)).
3603 -- A primitive operation may have an access parameter of an
3604 -- incomplete tagged type, but a dispatching call is illegal
3605 -- if the type is still incomplete.
3611 declare
3613 begin
3617 then
3618 Error_Msg_NE
3632 then
3637 then
3639 Error_Msg_NE
3649 and then
3654 -- Disable these checks for call to imported C++ subprograms
3656 and then not
3660 then
3661 Error_Msg_N
3666 then
3668 Error_Msg_NE
3675 -- If it is a named association, treat the selector_name as
3676 -- a proper identifier, and mark the corresponding entity.
3693 -- Case where actual is not present
3695 else
3696 Insert_Default;
3703 -----------------------
3704 -- Resolve_Allocator --
3705 -----------------------
3716 procedure Check_Allocator_Discrim_Accessibility
3719 -- Check that accessibility level associated with an access discriminant
3720 -- initialized in an allocator by the expression Disc_Exp is not deeper
3721 -- than the level of the allocator type Alloc_Typ. An error message is
3722 -- issued if this condition is violated. Specialized checks are done for
3723 -- the cases of a constraint expression which is an access attribute or
3724 -- an access discriminant.
3727 -- If the allocator is an actual in a call, it is allowed to be class-
3728 -- wide when the context is not because it is a controlling actual.
3731 -- Propagate all nested coextensions which are located one nesting
3732 -- level down the tree to the node Root. Example:
3733 --
3734 -- Top_Record
3735 -- Level_1_Coextension
3736 -- Level_2_Coextension
3737 --
3738 -- The algorithm is paired with delay actions done by the Expander. In
3739 -- the above example, assume all coextensions are controlled types.
3740 -- The cycle of analysis, resolution and expansion will yield:
3741 --
3742 -- 1) Analyze Top_Record
3743 -- 2) Analyze Level_1_Coextension
3744 -- 3) Analyze Level_2_Coextension
3745 -- 4) Resolve Level_2_Coextension. The allocator is marked as a
3746 -- coextension.
3747 -- 5) Expand Level_2_Coextension. A temporary variable Temp_1 is
3748 -- generated to capture the allocated object. Temp_1 is attached
3749 -- to the coextension chain of Level_2_Coextension.
3750 -- 6) Resolve Level_1_Coextension. The allocator is marked as a
3751 -- coextension. A forward tree traversal is performed which finds
3752 -- Level_2_Coextension's list and copies its contents into its
3753 -- own list.
3754 -- 7) Expand Level_1_Coextension. A temporary variable Temp_2 is
3755 -- generated to capture the allocated object. Temp_2 is attached
3756 -- to the coextension chain of Level_1_Coextension. Currently, the
3757 -- contents of the list are [Temp_2, Temp_1].
3758 -- 8) Resolve Top_Record. A forward tree traversal is performed which
3759 -- finds Level_1_Coextension's list and copies its contents into
3760 -- its own list.
3761 -- 9) Expand Top_Record. Generate finalization calls for Temp_1 and
3762 -- Temp_2 and attach them to Top_Record's finalization list.
3764 -------------------------------------------
3765 -- Check_Allocator_Discrim_Accessibility --
3766 -------------------------------------------
3768 procedure Check_Allocator_Discrim_Accessibility
3771 is
3772 begin
3775 then
3776 Error_Msg_N
3779 -- When the expression is an Access attribute the level of the prefix
3780 -- object must not be deeper than that of the allocator's type.
3784 = Attribute_Access
3787 then
3788 Error_Msg_N
3790 Disc_Exp);
3792 -- When the expression is an access discriminant the check is against
3793 -- the level of the prefix object.
3799 then
3800 Error_Msg_N
3802 Disc_Exp);
3804 -- All other cases are legal
3806 else
3811 ----------------------------
3812 -- In_Dispatching_Context --
3813 ----------------------------
3817 begin
3823 ----------------------------
3824 -- Propagate_Coextensions --
3825 ----------------------------
3830 -- Copy the contents of list From into list To, preserving the
3831 -- order of elements.
3834 -- Recognize an allocator or a rewritten allocator node and add it
3835 -- along with its nested coextensions to the list of Root.
3837 ---------------
3838 -- Copy_List --
3839 ---------------
3843 begin
3851 -----------------------
3852 -- Process_Allocator --
3853 -----------------------
3858 begin
3859 -- This is a possible rewritten subtype indication allocator. Any
3860 -- nested coextensions will appear as discriminant constraints.
3865 then
3866 declare
3870 begin
3872 Discr_Elmt :=
3882 then
3887 Copy_List
3895 -- There is no need to continue the traversal of this
3896 -- subtree since all the information has already been
3897 -- propagated.
3903 -- Case of either a stand alone allocator or a rewritten allocator
3904 -- with an aggregate.
3906 else
3913 -- Propagate the list of nested coextensions to the Root
3914 -- allocator. This is done through list copy since a single
3915 -- allocator may have multiple coextensions. Do not touch
3916 -- coextensions roots.
3920 then
3925 Copy_List
3930 -- There is no need to continue the traversal of this
3931 -- subtree since all the information has already been
3932 -- propagated.
3938 -- Keep on traversing, looking for the next allocator
3946 -- Start of processing for Propagate_Coextensions
3948 begin
3952 -- Start of processing for Resolve_Allocator
3954 begin
3955 -- Replace general access with specific type
3965 -- For qualified expression, resolve the expression using the
3966 -- given subtype (nothing to do for type mark, subtype indication)
3971 and then not In_Dispatching_Context
3972 then
3973 Error_Msg_N
3980 -- A qualified expression requires an exact match of the type,
3981 -- class-wide matching is not allowed.
3986 then
3990 -- A special accessibility check is needed for allocators that
3991 -- constrain access discriminants. The level of the type of the
3992 -- expression used to constrain an access discriminant cannot be
3993 -- deeper than the type of the allocator (in contrast to access
3994 -- parameters, where the level of the actual can be arbitrary).
3996 -- We can't use Valid_Conversion to perform this check because
3997 -- in general the type of the allocator is unrelated to the type
3998 -- of the access discriminant.
4002 then
4009 then
4012 -- Get the first component expression of the aggregate
4022 else
4026 else
4045 else
4050 else
4059 -- For a subtype mark or subtype indication, freeze the subtype
4061 else
4065 Error_Msg_N
4069 -- A special accessibility check is needed for allocators that
4070 -- constrain access discriminants. The level of the type of the
4071 -- expression used to constrain an access discriminant cannot be
4072 -- deeper than the type of the allocator (in contrast to access
4073 -- parameters, where the level of the actual can be arbitrary).
4074 -- We can't use Valid_Conversion to perform this check because
4075 -- in general the type of the allocator is unrelated to the type
4076 -- of the access discriminant.
4081 then
4091 else
4105 -- Ada 2005 (AI-344): A class-wide allocator requires an accessibility
4106 -- check that the level of the type of the created object is not deeper
4107 -- than the level of the allocator's access type, since extensions can
4108 -- now occur at deeper levels than their ancestor types. This is a
4109 -- static accessibility level check; a run-time check is also needed in
4110 -- the case of an initialized allocator with a class-wide argument (see
4111 -- Expand_Allocator_Expression).
4115 then
4116 declare
4119 begin
4124 else
4133 E);
4139 -- Do not apply Ada 2005 accessibility checks on a class-wide
4140 -- allocator if the type given in the allocator is a formal
4141 -- type. A run-time check will be performed in the instance.
4151 -- Check for allocation from an empty storage pool
4154 declare
4156 begin
4164 -- If the context is an unchecked conversion, as may happen within
4165 -- an inlined subprogram, the allocator is being resolved with its
4166 -- own anonymous type. In that case, if the target type has a specific
4167 -- storage pool, it must be inherited explicitly by the allocator type.
4171 then
4172 Set_Associated_Storage_Pool
4176 -- An erroneous allocator may be rewritten as a raise Program_Error
4177 -- statement.
4181 -- An anonymous access discriminant is the definition of a
4182 -- coextension.
4186 N_Discriminant_Specification
4187 then
4188 -- Avoid marking an allocator as a dynamic coextension if it is
4189 -- within a static construct.
4195 -- Cleanup for potential static coextensions
4197 else
4202 -- There is no need to propagate any nested coextensions if they
4203 -- are marked as static since they will be rewritten on the spot.
4211 ---------------------------
4212 -- Resolve_Arithmetic_Op --
4213 ---------------------------
4215 -- Used for resolving all arithmetic operators except exponentiation
4226 -- We do the resolution using the base type, because intermediate values
4227 -- in expressions always are of the base type, not a subtype of it.
4230 -- Returns True if N is in a context that expects "any real type"
4233 -- Return True iff given type is Integer or universal real/integer
4236 -- Choose type of integer literal in fixed-point operation to conform
4237 -- to available fixed-point type. T is the type of the other operand,
4238 -- which is needed to determine the expected type of N.
4241 -- Set operand type to T if universal
4243 -------------------------------
4244 -- Expected_Type_Is_Any_Real --
4245 -------------------------------
4248 begin
4249 -- N is the expression after "delta" in a fixed_point_definition;
4250 -- see RM-3.5.9(6):
4253 N_Decimal_Fixed_Point_Definition,
4255 -- N is one of the bounds in a real_range_specification;
4256 -- see RM-3.5.7(5):
4258 N_Real_Range_Specification,
4260 -- N is the expression of a delta_constraint;
4261 -- see RM-J.3(3):
4263 N_Delta_Constraint);
4266 -----------------------------
4267 -- Is_Integer_Or_Universal --
4268 -----------------------------
4275 begin
4281 else
4287 then
4298 ----------------------------
4299 -- Set_Mixed_Mode_Operand --
4300 ----------------------------
4306 begin
4309 -- A universal integer literal is resolved as standard integer
4310 -- except in the case of a fixed-point result, where we leave it
4311 -- as universal (to be handled by Exp_Fixd later on)
4315 else
4323 then
4324 -- A universal real can appear in a fixed-type context. We resolve
4325 -- the literal with that context, even though this might raise an
4326 -- exception prematurely (the other operand may be zero).
4333 then
4334 -- Integer arg in mixed-mode operation. Resolve with universal
4335 -- type, in case preference rule must be applied.
4341 then
4342 -- Not a mixed-mode operation, resolve with context
4348 -- N may itself be a mixed-mode operation, so use context type
4355 then
4356 -- Must be (fixed * fixed) operation, operand must have one
4357 -- compatible interpretation.
4365 then
4366 -- C * F(X) in a fixed context, where C is a real literal or a
4367 -- fixed-point expression. F must have either a fixed type
4368 -- interpretation or an integer interpretation, but not both.
4376 else
4384 else
4392 -- Reanalyze the literal with the fixed type of the context. If
4393 -- context is Universal_Fixed, we are within a conversion, leave
4394 -- the literal as a universal real because there is no usable
4395 -- fixed type, and the target of the conversion plays no role in
4396 -- the resolution.
4398 declare
4402 begin
4405 else
4411 then
4413 else
4421 else
4426 ----------------------
4427 -- Set_Operand_Type --
4428 ----------------------
4431 begin
4434 then
4439 -- Start of processing for Resolve_Arithmetic_Op
4441 begin
4446 then
4450 -- Special-case for mixed-mode universal expressions or fixed point
4451 -- type operation: each argument is resolved separately. The same
4452 -- treatment is required if one of the operands of a fixed point
4453 -- operation is universal real, since in this case we don't do a
4454 -- conversion to a specific fixed-point type (instead the expander
4455 -- takes care of the case).
4460 then
4471 or else
4474 then
4479 -- If context is a fixed type and one operand is integer, the
4480 -- other is resolved with the type of the context.
4485 then
4492 then
4496 else
4501 -- Check the rule in RM05-4.5.5(19.1/2) disallowing universal_fixed
4502 -- multiplying operators from being used when the expected type is
4503 -- also universal_fixed. Note that B_Typ will be Universal_Fixed in
4504 -- some cases where the expected type is actually Any_Real;
4505 -- Expected_Type_Is_Any_Real takes care of that case.
4509 then
4513 N_Unchecked_Type_Conversion)
4514 then
4521 else
4524 and then not
4526 N_Unchecked_Type_Conversion)
4527 then
4528 Error_Msg_N
4533 -- The expected type is "any real type" in contexts like
4534 -- type T is delta <universal_fixed-expression> ...
4535 -- in which case we need to set the type to Universal_Real
4536 -- so that static expression evaluation will work properly.
4540 else
4550 then
4555 -- If no previous errors, this is only possible if one operand
4556 -- is overloaded and the context is universal. Resolve as such.
4561 else
4563 and then
4565 then
4569 -- If the context is Universal_Fixed and the operands are also
4570 -- universal fixed, this is an error, unless there is only one
4571 -- applicable fixed_point type (usually duration).
4579 else
4584 else
4589 -- If one of the arguments was resolved to a non-universal type.
4590 -- label the result of the operation itself with the same type.
4591 -- Do the same for the universal argument, if any.
4602 -- Set overflow and division checking bit. Much cleverer code needed
4603 -- here eventually and perhaps the Resolve routines should be separated
4604 -- for the various arithmetic operations, since they will need
4605 -- different processing. ???
4612 -- Give warning if explicit division by zero
4616 then
4622 or else
4625 then
4626 -- Specialize the warning message according to the operation
4630 Apply_Compile_Time_Constraint_Error
4635 Apply_Compile_Time_Constraint_Error
4640 Apply_Compile_Time_Constraint_Error
4644 -- Division by zero can only happen with division, rem,
4645 -- and mod operations.
4651 -- Otherwise just set the flag to check at run time
4653 else
4658 -- If Restriction No_Implicit_Conditionals is active, then it is
4659 -- violated if either operand can be negative for mod, or for rem
4660 -- if both operands can be negative.
4664 then
4665 declare
4672 -- Set if corresponding operand might be negative
4674 begin
4675 Determine_Range
4679 Determine_Range
4683 -- Check if we will be generating conditionals. There are two
4684 -- cases where that can happen, first for REM, the only case
4685 -- is largest negative integer mod -1, where the division can
4686 -- overflow, but we still have to give the right result. The
4687 -- front end generates a test for this annoying case. Here we
4688 -- just test if both operands can be negative (that's what the
4689 -- expander does, so we match its logic here).
4691 -- The second case is mod where either operand can be negative.
4692 -- In this case, the back end has to generate additonal tests.
4695 or else
4697 then
4708 ------------------
4709 -- Resolve_Call --
4710 ------------------
4722 begin
4723 -- The context imposes a unique interpretation with type Typ on a
4724 -- procedure or function call. Find the entity of the subprogram that
4725 -- yields the expected type, and propagate the corresponding formal
4726 -- constraints on the actuals. The caller has established that an
4727 -- interpretation exists, and emitted an error if not unique.
4729 -- First deal with the case of a call to an access-to-subprogram,
4730 -- dereference made explicit in Analyze_Call.
4736 else
4737 -- Find the interpretation whose type (a subprogram type) has a
4738 -- return type that is compatible with the context. Analysis of
4739 -- the node has established that one exists.
4758 -- If the prefix is not an entity, then resolve it
4764 -- For an indirect call, we always invalidate checks, since we do not
4765 -- know whether the subprogram is local or global. Yes we could do
4766 -- better here, e.g. by knowing that there are no local subprograms,
4767 -- but it does not seem worth the effort. Similarly, we kill all
4768 -- knowledge of current constant values.
4770 Kill_Current_Values;
4772 -- If this is a procedure call which is really an entry call, do
4773 -- the conversion of the procedure call to an entry call. Protected
4774 -- operations use the same circuitry because the name in the call
4775 -- can be an arbitrary expression with special resolution rules.
4780 then
4784 -- Kill checks and constant values, as above for indirect case
4785 -- Who knows what happens when another task is activated?
4787 Kill_Current_Values;
4790 -- Normal subprogram call with name established in Resolve
4796 -- Otherwise we must have the case of an overloaded call
4798 else
4801 -- Initialize Nam to prevent warning (we know it will be assigned
4802 -- in the loop below, but the compiler does not know that).
4822 then
4823 -- The prefix is a parameterless function call that returns an access
4824 -- to subprogram. If parameters are present in the current call, add
4825 -- add an explicit dereference. We use the base type here because
4826 -- within an instance these may be subtypes.
4828 -- The dereference is added either in Analyze_Call or here. Should
4829 -- be consolidated ???
4838 -- Check that a call to Current_Task does not occur in an entry body
4841 declare
4844 begin
4846 loop
4849 -- Exclude calls that occur within the default of a formal
4850 -- parameter of the entry, since those are evaluated outside
4851 -- of the body.
4858 then
4860 Error_Msg_NE
4863 Error_Msg_NE
4875 -- Check that a procedure call does not occur in the context of the
4876 -- entry call statement of a conditional or timed entry call. Note that
4877 -- the case of a call to a subprogram renaming of an entry will also be
4878 -- rejected. The test for N not being an N_Entry_Call_Statement is
4879 -- defensive, covering the possibility that the processing of entry
4880 -- calls might reach this point due to later modifications of the code
4881 -- above.
4886 then
4890 -- Ada 2005 (AI-345): If a procedure_call_statement is used
4891 -- for a procedure_or_entry_call, the procedure_name or
4892 -- procedure_prefix of the procedure_call_statement shall denote
4893 -- an entry renamed by a procedure, or (a view of) a primitive
4894 -- subprogram of a limited interface whose first parameter is
4895 -- a controlling parameter.
4900 then
4901 Error_Msg_N
4906 -- Check that this is not a call to a protected procedure or entry from
4907 -- within a protected function.
4913 then
4919 -- Freeze the subprogram name if not in a spec-expression. Note that we
4920 -- freeze procedure calls as well as function calls. Procedure calls are
4921 -- not frozen according to the rules (RM 13.14(14)) because it is
4922 -- impossible to have a procedure call to a non-frozen procedure in pure
4923 -- Ada, but in the code that we generate in the expander, this rule
4924 -- needs extending because we can generate procedure calls that need
4925 -- freezing.
4931 -- For a predefined operator, the type of the result is the type imposed
4932 -- by context, except for a predefined operation on universal fixed.
4933 -- Otherwise The type of the call is the type returned by the subprogram
4934 -- being called.
4941 -- If the subprogram returns an array type, and the context requires the
4942 -- component type of that array type, the node is really an indexing of
4943 -- the parameterless call. Resolve as such. A pathological case occurs
4944 -- when the type of the component is an access to the array type. In
4945 -- this case the call is truly ambiguous.
4948 and then
4953 and then
4956 then
4957 declare
4962 begin
4965 then
4966 Error_Msg_N
4968 else
4974 or else
4976 and then
4978 then
4981 -- Indexed call to a parameterless function
4983 Index_Node :=
4985 Prefix =>
4989 else
4990 -- An Ada 2005 prefixed call to a primitive operation
4991 -- whose first parameter is the prefix. This prefix was
4992 -- prepended to the parameter list, which is actually a
4993 -- list of indices. Remove the prefix in order to build
4994 -- the proper indexed component.
4996 Index_Node :=
4998 Prefix =>
5001 Parameter_Associations =>
5002 New_List
5007 -- Since we are correcting a node classification error made
5008 -- by the parser, we call Replace rather than Rewrite.
5021 else
5025 -- In the case where the call is to an overloaded subprogram, Analyze
5026 -- calls Normalize_Actuals once per overloaded subprogram. Therefore in
5027 -- such a case Normalize_Actuals needs to be called once more to order
5028 -- the actuals correctly. Otherwise the call will have the ordering
5029 -- given by the last overloaded subprogram whether this is the correct
5030 -- one being called or not.
5037 -- In any case, call is fully resolved now. Reset Overload flag, to
5038 -- prevent subsequent overload resolution if node is analyzed again
5043 -- If we are calling the current subprogram from immediately within its
5044 -- body, then that is the case where we can sometimes detect cases of
5045 -- infinite recursion statically. Do not try this in case restriction
5046 -- No_Recursion is in effect anyway, and do it only for source calls.
5051 -- Issue warning for possible infinite recursion in the absence
5052 -- of the No_Recursion restriction.
5057 then
5058 -- Here we detected and flagged an infinite recursion, so we do
5059 -- not need to test the case below for further warnings. Also if
5060 -- we now have a raise SE node, we are all done.
5066 -- If call is to immediately containing subprogram, then check for
5067 -- the case of a possible run-time detectable infinite recursion.
5069 else
5073 -- Although in general case, recursion is not statically
5074 -- checkable, the case of calling an immediately containing
5075 -- subprogram is easy to catch.
5079 -- If the recursive call is to a parameterless subprogram,
5080 -- then even if we can't statically detect infinite
5081 -- recursion, this is pretty suspicious, and we output a
5082 -- warning. Furthermore, we will try later to detect some
5083 -- cases here at run time by expanding checking code (see
5084 -- Detect_Infinite_Recursion in package Exp_Ch6).
5086 -- If the recursive call is within a handler, do not emit a
5087 -- warning, because this is a common idiom: loop until input
5088 -- is correct, catch illegal input in handler and restart.
5094 then
5095 -- For the case of a procedure call. We give the message
5096 -- only if the call is the first statement in a sequence
5097 -- of statements, or if all previous statements are
5098 -- simple assignments. This is simply a heuristic to
5099 -- decrease false positives, without losing too many good
5100 -- warnings. The idea is that these previous statements
5101 -- may affect global variables the procedure depends on.
5105 then
5106 declare
5108 begin
5120 -- Do not give warning if we are in a conditional context
5122 declare
5124 begin
5130 then
5135 -- Here warning is to be issued
5138 Error_Msg_N
5140 Error_Msg_N
5152 -- If subprogram name is a predefined operator, it was given in
5153 -- functional notation. Replace call node with operator node, so
5154 -- that actuals can be resolved appropriately.
5162 then
5168 -- Create a transient scope if the resulting type requires it
5170 -- There are several notable exceptions:
5172 -- a) In init procs, the transient scope overhead is not needed, and is
5173 -- even incorrect when the call is a nested initialization call for a
5174 -- component whose expansion may generate adjust calls. However, if the
5175 -- call is some other procedure call within an initialization procedure
5176 -- (for example a call to Create_Task in the init_proc of the task
5177 -- run-time record) a transient scope must be created around this call.
5179 -- b) Enumeration literal pseudo-calls need no transient scope
5181 -- c) Intrinsic subprograms (Unchecked_Conversion and source info
5182 -- functions) do not use the secondary stack even though the return
5183 -- type may be unconstrained.
5185 -- d) Calls to a build-in-place function, since such functions may
5186 -- allocate their result directly in a target object, and cases where
5187 -- the result does get allocated in the secondary stack are checked for
5188 -- within the specialized Exp_Ch6 procedures for expanding those
5189 -- build-in-place calls.
5191 -- e) If the subprogram is marked Inline_Always, then even if it returns
5192 -- an unconstrained type the call does not require use of the secondary
5193 -- stack. However, inlining will only take place if the body to inline
5194 -- is already present. It may not be available if e.g. the subprogram is
5195 -- declared in a child instance.
5197 -- If this is an initialization call for a type whose construction
5198 -- uses the secondary stack, and it is not a nested call to initialize
5199 -- a component, we do need to create a transient scope for it. We
5200 -- check for this by traversing the type in Check_Initialization_Call.
5206 then
5212 then
5215 elsif Expander_Active
5218 and then
5220 or else
5222 then
5225 -- If the call appears within the bounds of a loop, it will
5226 -- be rewritten and reanalyzed, nothing left to do here.
5233 and then not Within_Init_Proc
5234 then
5238 -- A protected function cannot be called within the definition of the
5239 -- enclosing protected type.
5244 then
5245 Error_Msg_NE
5249 -- Propagate interpretation to actuals, and add default expressions
5250 -- where needed.
5255 -- Overloaded literals are rewritten as function calls, for purpose of
5256 -- resolution. After resolution, we can replace the call with the
5257 -- literal itself.
5263 -- Avoid validation, since it is a static function call
5269 -- If the subprogram is not global, then kill all saved values and
5270 -- checks. This is a bit conservative, since in many cases we could do
5271 -- better, but it is not worth the effort. Similarly, we kill constant
5272 -- values. However we do not need to do this for internal entities
5273 -- (unless they are inherited user-defined subprograms), since they
5274 -- are not in the business of molesting local values.
5276 -- If the flag Suppress_Value_Tracking_On_Calls is set, then we also
5277 -- kill all checks and values for calls to global subprograms. This
5278 -- takes care of the case where an access to a local subprogram is
5279 -- taken, and could be passed directly or indirectly and then called
5280 -- from almost any context.
5282 -- Note: we do not do this step till after resolving the actuals. That
5283 -- way we still take advantage of the current value information while
5284 -- scanning the actuals.
5286 -- We suppress killing values if we are processing the nodes associated
5287 -- with N_Freeze_Entity nodes. Otherwise the declaration of a tagged
5288 -- type kills all the values as part of analyzing the code that
5289 -- initializes the dispatch tables.
5293 or else Suppress_Value_Tracking_On_Call
5298 then
5299 Kill_Current_Values;
5302 -- If we are warning about unread OUT parameters, this is the place to
5303 -- set Last_Assignment for OUT and IN OUT parameters. We have to do this
5304 -- after the above call to Kill_Current_Values (since that call clears
5305 -- the Last_Assignment field of all local variables).
5310 then
5311 declare
5315 begin
5320 or else
5327 then
5337 -- If the subprogram is a primitive operation, check whether or not
5338 -- it is a correct dispatching call.
5342 then
5347 and then not In_Instance
5348 then
5352 -- If this is a dispatching call, generate the appropriate reference,
5353 -- for better source navigation in GPS.
5357 then
5360 -- Normal case, not a dispatching call
5362 else
5370 -- Check for violation of restriction No_Specific_Termination_Handlers
5371 -- and warn on a potentially blocking call to Abort_Task.
5374 or else
5376 then
5383 -- Issue an error for a call to an eliminated subprogram
5387 -- All done, evaluate call and deal with elaboration issues
5394 -------------------------------
5395 -- Resolve_Character_Literal --
5396 -------------------------------
5402 begin
5403 -- Verify that the character does belong to the type of the context
5408 -- Wide_Wide_Character literals must always be defined, since the set
5409 -- of wide wide character literals is complete, i.e. if a character
5410 -- literal is accepted by the parser, then it is OK for wide wide
5411 -- character (out of range character literals are rejected).
5416 -- Always accept character literal for type Any_Character, which
5417 -- occurs in error situations and in comparisons of literals, both
5418 -- of which should accept all literals.
5423 -- For Standard.Character or a type derived from it, check that
5424 -- the literal is in range
5431 -- For Standard.Wide_Character or a type derived from it, check
5432 -- that the literal is in range
5439 -- For Standard.Wide_Wide_Character or a type derived from it, we
5440 -- know the literal is in range, since the parser checked!
5445 -- If the entity is already set, this has already been resolved in a
5446 -- generic context, or comes from expansion. Nothing else to do.
5451 -- Otherwise we have a user defined character type, and we can use the
5452 -- standard visibility mechanisms to locate the referenced entity.
5454 else
5467 -- If we fall through, then the literal does not match any of the
5468 -- entries of the enumeration type. This isn't just a constraint
5469 -- error situation, it is an illegality (see RM 4.2).
5471 Error_Msg_NE
5475 ---------------------------
5476 -- Resolve_Comparison_Op --
5477 ---------------------------
5479 -- Context requires a boolean type, and plays no role in resolution.
5480 -- Processing identical to that for equality operators. The result
5481 -- type is the base type, which matters when pathological subtypes of
5482 -- booleans with limited ranges are used.
5489 begin
5490 -- If this is an intrinsic operation which is not predefined, use the
5491 -- types of its declared arguments to resolve the possibly overloaded
5492 -- operands. Otherwise the operands are unambiguous and specify the
5493 -- expected type.
5498 else
5512 T = Any_Character
5513 then
5516 else
5523 else
5535 ------------------------------------
5536 -- Resolve_Conditional_Expression --
5537 ------------------------------------
5544 begin
5548 -- If ELSE expression present, just resolve using the determined type
5553 -- If no ELSE expression is present, root type must be Standard.Boolean
5554 -- and we provide a Standard.True result converted to the appropriate
5555 -- Boolean type (in case it is a derived boolean type).
5558 Else_Expr :=
5563 else
5572 -----------------------------------------
5573 -- Resolve_Discrete_Subtype_Indication --
5574 -----------------------------------------
5576 procedure Resolve_Discrete_Subtype_Indication
5579 is
5583 begin
5591 else
5601 Error_Msg_NE
5604 -- Rewrite the constraint as a range of Typ
5605 -- to allow compilation to proceed further.
5617 else
5621 -- Additionally, we must check that the bounds are compatible
5622 -- with the given subtype, which might be different from the
5623 -- type of the context.
5627 -- ??? If the above check statically detects a Constraint_Error
5628 -- it replaces the offending bound(s) of the range R with a
5629 -- Constraint_Error node. When the itype which uses these bounds
5630 -- is frozen the resulting call to Duplicate_Subexpr generates
5631 -- a new temporary for the bounds.
5633 -- Unfortunately there are other itypes that are also made depend
5634 -- on these bounds, so when Duplicate_Subexpr is called they get
5635 -- a forward reference to the newly created temporaries and Gigi
5636 -- aborts on such forward references. This is probably sign of a
5637 -- more fundamental problem somewhere else in either the order of
5638 -- itype freezing or the way certain itypes are constructed.
5640 -- To get around this problem we call Remove_Side_Effects right
5641 -- away if either bounds of R are a Constraint_Error.
5643 declare
5647 begin
5663 -------------------------
5664 -- Resolve_Entity_Name --
5665 -------------------------
5667 -- Used to resolve identifiers and expanded names
5672 begin
5673 -- If garbage from errors, set to Any_Type and return
5680 -- Replace named numbers by corresponding literals. Note that this is
5681 -- the one case where Resolve_Entity_Name must reset the Etype, since
5682 -- it is currently marked as universal.
5692 -- Allow use of subtype only if it is a concurrent type where we are
5693 -- currently inside the body. This will eventually be expanded into a
5694 -- call to Self (for tasks) or _object (for protected objects). Any
5695 -- other use of a subtype is invalid.
5700 then
5702 else
5703 Error_Msg_N
5707 -- Check discriminant use if entity is discriminant in current scope,
5708 -- i.e. discriminant of record or concurrent type currently being
5709 -- analyzed. Uses in corresponding body are unrestricted.
5714 then
5717 -- A parameterless generic function cannot appear in a context that
5718 -- requires resolution.
5729 then
5732 -- In all other cases, just do the possible static evaluation
5734 else
5735 -- A deferred constant that appears in an expression must have a
5736 -- completion, unless it has been removed by in-place expansion of
5737 -- an aggregate.
5743 and then not In_Spec_Expression
5745 then
5750 then
5752 else
5753 Error_Msg_N (
5762 -------------------
5763 -- Resolve_Entry --
5764 -------------------
5776 -- If the bounds of the entry family being called depend on task
5777 -- discriminants, build a new index subtype where a discriminant is
5778 -- replaced with the value of the discriminant of the target task.
5779 -- The target task is the prefix of the entry name in the call.
5781 -----------------------
5782 -- Actual_Index_Type --
5783 -----------------------
5793 -- If the bound is given by a discriminant, replace with a reference
5794 -- to the discriminant of the same name in the target task. If the
5795 -- entry name is the target of a requeue statement and the entry is
5796 -- in the current protected object, the bound to be used is the
5797 -- discriminal of the object (see apply_range_checks for details of
5798 -- the transformation).
5800 -----------------------------
5801 -- Actual_Discriminant_Ref --
5802 -----------------------------
5808 begin
5813 then
5819 then
5822 else
5823 Ref :=
5833 -- Start of processing for Actual_Index_Type
5835 begin
5838 and then
5840 then
5843 else
5857 -- Start of processing of Resolve_Entry
5859 begin
5860 -- Find name of entry being called, and resolve prefix of name
5861 -- with its own type. The prefix can be overloaded, and the name
5862 -- and signature of the entry must be taken into account.
5866 -- Case of dealing with entry family within the current tasks
5870 else
5876 -- Entry call to an entry (or entry family) in the current task. This
5877 -- is legal even though the task will deadlock. Rewrite as call to
5878 -- current task.
5880 -- This can also be a call to an entry in an enclosing task. If this
5881 -- is a single task, we have to retrieve its name, because the scope
5882 -- of the entry is the task type, not the object. If the enclosing
5883 -- task is a task type, the identity of the task is given by its own
5884 -- self variable.
5886 -- Finally this can be a requeue on an entry of the same task or
5887 -- protected object.
5894 then
5895 -- S is an enclosing task or protected object. The concurrent
5896 -- declaration has been converted into a type declaration, and
5897 -- the object itself has an object declaration that follows
5898 -- the type in the same declarative part.
5910 -- Call to current task. Will be transformed into call to Self
5917 New_N :=
5920 Selector_Name =>
5927 then
5928 -- Use the entry name (which must be unique at this point) to find
5929 -- the prefix that returns the corresponding task type or protected
5930 -- type.
5932 declare
5938 begin
5960 -- Up to this point the expression could have been the actual in a
5961 -- simple entry call, and be given by a named association.
5965 else
5971 ------------------------
5972 -- Resolve_Entry_Call --
5973 ------------------------
5985 begin
5986 -- We kill all checks here, because it does not seem worth the effort to
5987 -- do anything better, an entry call is a big operation.
5989 Kill_All_Checks;
5991 -- Processing of the name is similar for entry calls and protected
5992 -- operation calls. Once the entity is determined, we can complete
5993 -- the resolution of the actuals.
5995 -- The selector may be overloaded, in the case of a protected object
5996 -- with overloaded functions. The type of the context is used for
5997 -- resolution.
6002 then
6003 declare
6007 begin
6026 -- Simple entry call
6034 -- Call to member of entry family
6041 -- We cannot in general check the maximum depth of protected entry
6042 -- calls at compile time. But we can tell that any protected entry
6043 -- call at all violates a specified nesting depth of zero.
6049 -- Use context type to disambiguate a protected function that can be
6050 -- called without actuals and that returns an array type, and where
6051 -- the argument list may be an indexing of the returned value.
6056 and then
6064 then
6065 declare
6068 begin
6069 Index_Node :=
6071 Prefix =>
6076 -- Since we are correcting a node classification error made by
6077 -- the parser, we call Replace rather than Rewrite.
6087 -- The operation name may have been overloaded. Order the actuals
6088 -- according to the formals of the resolved entity, and set the
6089 -- return type to that of the operation.
6102 then
6106 -- Verify that a procedure call cannot masquerade as an entry
6107 -- call where an entry call is expected.
6112 then
6117 then
6122 then
6127 -- After resolution, entry calls and protected procedure calls are
6128 -- changed into entry calls, for expansion. The structure of the node
6129 -- does not change, so it can safely be done in place. Protected
6130 -- function calls must keep their structure because they are
6131 -- subexpressions.
6135 -- A protected operation that is not a function may modify the
6136 -- corresponding object, and cannot apply to a constant. If this
6137 -- is an internal call, the prefix is the type itself.
6143 then
6144 Error_Msg_N
6146 Entry_Name);
6160 -- Protected functions can return on the secondary stack, in which
6161 -- case we must trigger the transient scope mechanism.
6163 elsif Expander_Active
6165 then
6170 -------------------------
6171 -- Resolve_Equality_Op --
6172 -------------------------
6174 -- Both arguments must have the same type, and the boolean context does
6175 -- not participate in the resolution. The first pass verifies that the
6176 -- interpretation is not ambiguous, and the type of the left argument is
6177 -- correctly set, or is Any_Type in case of ambiguity. If both arguments
6178 -- are strings or aggregates, allocators, or Null, they are ambiguous even
6179 -- though they carry a single (universal) type. Diagnose this case here.
6187 -- In the case of allocators, make a last-ditch attempt to find a single
6188 -- access type with the right designated type. This is semantically
6189 -- dubious, and of no interest to any real code, but c48008a makes it
6190 -- all worthwhile.
6192 -----------------------------
6193 -- Find_Unique_Access_Type --
6194 -----------------------------
6201 begin
6206 else
6218 then
6231 -- Start of processing for Resolve_Equality_Op
6233 begin
6245 then
6248 else
6258 then
6271 -- If the unique type is a class-wide type then it will be expanded
6272 -- into a dispatching call to the predefined primitive. Therefore we
6273 -- check here for potential violation of such restriction.
6279 if Warn_On_Redundant_Constructs
6284 then
6293 -- If this is an inequality, it may be the implicit inequality
6294 -- created for a user-defined operation, in which case the corres-
6295 -- ponding equality operation is not intrinsic, and the operation
6296 -- cannot be constant-folded. Else fold.
6301 or else Is_Intrinsic_Subprogram
6303 then
6308 then
6312 -- Ada 2005: If one operand is an anonymous access type, convert the
6313 -- other operand to it, to ensure that the underlying types match in
6314 -- the back-end. Same for access_to_subprogram, and the conversion
6315 -- verifies that the types are subtype conformant.
6317 -- We apply the same conversion in the case one of the operands is a
6318 -- private subtype of the type of the other.
6320 -- Why the Expander_Active test here ???
6322 if Expander_Active
6323 and then
6327 then
6347 ----------------------------------
6348 -- Resolve_Explicit_Dereference --
6349 ----------------------------------
6358 begin
6363 -- Use the context type to select the prefix that has the correct
6364 -- designated type.
6375 else
6376 -- If no interpretation covers the designated type of the prefix,
6377 -- this is the pathological case where not all implementations of
6378 -- the prefix allow the interpretation of the node as a call. Now
6379 -- that the expected type is known, Remove other interpretations
6380 -- from prefix, rewrite it as a call, and resolve again, so that
6381 -- the proper call node is generated.
6392 New_N :=
6394 Name =>
6407 else
6415 -- If the designated type is a packed unconstrained array type, and the
6416 -- explicit dereference is not in the context of an attribute reference,
6417 -- then we must compute and set the actual subtype, since it is needed
6418 -- by Gigi. The reason we exclude the attribute case is that this is
6419 -- handled fine by Gigi, and in fact we use such attributes to build the
6420 -- actual subtype. We also exclude generated code (which builds actual
6421 -- subtypes directly if they are needed).
6428 then
6432 -- Note: No Eval processing is required for an explicit dereference,
6433 -- because such a name can never be static.
6437 -------------------------------
6438 -- Resolve_Indexed_Component --
6439 -------------------------------
6447 begin
6450 -- Use the context type to select the prefix that yields the correct
6451 -- component type.
6453 declare
6460 begin
6467 and then Covers
6469 then
6478 else
6484 else
6495 else
6502 -- If prefix is access type, dereference to get real array type.
6503 -- Note: we do not apply an access check because the expander always
6504 -- introduces an explicit dereference, and the check will happen there.
6510 -- If name was overloaded, set component type correctly now
6511 -- If a misplaced call to an entry family (which has no index types)
6512 -- return. Error will be diagnosed from calling context.
6516 else
6523 -- The prefix may have resolved to a string literal, in which case its
6524 -- etype has a special representation. This is only possible currently
6525 -- if the prefix is a static concatenation, written in functional
6526 -- notation.
6531 else
6538 else
6547 -- Do not generate the warning on suspicious index if we are analyzing
6548 -- package Ada.Tags; otherwise we will report the warning with the
6549 -- Prims_Ptr field of the dispatch table.
6552 or else not
6554 Ada_Tags)
6555 then
6561 -----------------------------
6562 -- Resolve_Integer_Literal --
6563 -----------------------------
6566 begin
6571 --------------------------------
6572 -- Resolve_Intrinsic_Operator --
6573 --------------------------------
6581 begin
6591 -- If the operand type is private, rewrite with suitable conversions on
6592 -- the operands and the result, to expose the proper underlying numeric
6593 -- type.
6600 else
6616 then
6617 -- Add explicit conversion where needed, and save interpretations in
6618 -- case operands are overloaded.
6625 else
6631 else
6641 else
6646 --------------------------------------
6647 -- Resolve_Intrinsic_Unary_Operator --
6648 --------------------------------------
6650 procedure Resolve_Intrinsic_Unary_Operator
6653 is
6658 begin
6677 else
6682 ------------------------
6683 -- Resolve_Logical_Op --
6684 ------------------------
6689 begin
6692 -- Predefined operations on scalar types yield the base type. On the
6693 -- other hand, logical operations on arrays yield the type of the
6694 -- arguments (and the context).
6698 else
6702 -- The following test is required because the operands of the operation
6703 -- may be literals, in which case the resulting type appears to be
6704 -- compatible with a signed integer type, when in fact it is compatible
6705 -- only with modular types. If the context itself is universal, the
6706 -- operation is illegal.
6714 Error_Msg_N
6721 then
6736 ---------------------------
6737 -- Resolve_Membership_Op --
6738 ---------------------------
6740 -- The context can only be a boolean type, and does not determine
6741 -- the arguments. Arguments should be unambiguous, but the preference
6742 -- rule for universal types applies.
6752 -- Analysis has determined a unique type for the left operand.
6753 -- Use it to resolve the disjuncts.
6755 ----------------------------
6756 -- Resolve_Set_Membership --
6757 ----------------------------
6762 begin
6768 -- Alternative is an expression, a range
6769 -- or a subtype mark.
6773 then
6781 -- Start of processing for Resolve_Membership_Op
6783 begin
6789 Resolve_Set_Membership;
6793 and then
6797 then
6800 -- Ada 2005 (AI-251): Support the following case:
6802 -- type I is interface;
6803 -- type T is tagged ...
6805 -- function Test (O : I'Class) is
6806 -- begin
6807 -- return O in T'Class.
6808 -- end Test;
6810 -- In this case we have nothing else to do. The membership test will be
6811 -- done at run-time.
6818 then
6821 else
6830 then
6836 else
6844 ------------------
6845 -- Resolve_Null --
6846 ------------------
6851 begin
6852 -- Handle restriction against anonymous null access values This
6853 -- restriction can be turned off using -gnatdj.
6855 -- Ada 2005 (AI-231): Remove restriction
6858 and then not Debug_Flag_J
6861 then
6862 -- In the common case of a call which uses an explicitly null value
6863 -- for an access parameter, give specialized error message.
6866 N_Function_Call)
6867 then
6868 Error_Msg_N
6871 -- Standard message for all other cases (are there any?)
6873 else
6874 Error_Msg_N
6879 -- Ada 2005 (AI-231): Generate the null-excluding check in case of
6880 -- assignment to a null-excluding object
6885 then
6887 Insert_Action
6892 else
6899 -- In a distributed context, null for a remote access to subprogram may
6900 -- need to be replaced with a special record aggregate. In this case,
6901 -- return after having done the transformation.
6906 then
6910 -- The null literal takes its type from the context
6915 -----------------------
6916 -- Resolve_Op_Concat --
6917 -----------------------
6921 -- We wish to avoid deep recursion, because concatenations are often
6922 -- deeply nested, as in A&B&...&Z. Therefore, we walk down the left
6923 -- operands nonrecursively until we find something that is not a simple
6924 -- concatenation (A in this case). We resolve that, and then walk back
6925 -- up the tree following Parent pointers, calling Resolve_Op_Concat_Rest
6926 -- to do the rest of the work at each level. The Parent pointers allow
6927 -- us to avoid recursion, and thus avoid running out of memory. See also
6928 -- Sem_Ch4.Analyze_Concatenation, where a similar approach is used.
6933 begin
6934 -- The following code is equivalent to:
6936 -- Resolve_Op_Concat_First (NN, Typ);
6937 -- Resolve_Op_Concat_Arg (N, ...);
6938 -- Resolve_Op_Concat_Rest (N, Typ);
6940 -- where the Resolve_Op_Concat_Arg call recurses back here if the left
6941 -- operand is a concatenation.
6943 -- Walk down left operands
6945 loop
6954 -- Now (given the above example) NN is A&B and Op1 is A
6956 -- First resolve Op1 ...
6960 -- ... then walk NN back up until we reach N (where we started), calling
6961 -- Resolve_Op_Concat_Rest along the way.
6963 loop
6970 ---------------------------
6971 -- Resolve_Op_Concat_Arg --
6972 ---------------------------
6974 procedure Resolve_Op_Concat_Arg
6979 is
6982 begin
6984 if Is_Comp
6988 then
6990 else
6997 then
7000 else
7005 else
7009 then
7010 declare
7015 begin
7020 -- Special-case the error message when the overloading is
7021 -- caused by a function that yields an array and can be
7022 -- called without parameters.
7027 Error_Msg_NE
7029 Error_Msg_NE
7033 else
7034 Error_Msg_N
7043 then
7044 Error_Msg_N -- CODEFIX
7062 else
7067 else
7074 -----------------------------
7075 -- Resolve_Op_Concat_First --
7076 -----------------------------
7083 begin
7084 -- The parser folds an enormous sequence of concatenations of string
7085 -- literals into "" & "...", where the Is_Folded_In_Parser flag is set
7086 -- in the right operand. If the expression resolves to a predefined "&"
7087 -- operator, all is well. Otherwise, the parser's folding is wrong, so
7088 -- we give an error. See P_Simple_Expression in Par.Ch4.
7093 then
7108 ----------------------------
7109 -- Resolve_Op_Concat_Rest --
7110 ----------------------------
7116 begin
7125 -- If this is not a static concatenation, but the result is a string
7126 -- type (and not an array of strings) ensure that static string operands
7127 -- have their subtypes properly constructed.
7131 then
7137 ----------------------
7138 -- Resolve_Op_Expon --
7139 ----------------------
7144 begin
7145 -- Catch attempts to do fixed-point exponentiation with universal
7146 -- operands, which is a case where the illegality is not caught during
7147 -- normal operator analysis.
7158 then
7165 then
7169 -- We do the resolution using the base type, because intermediate values
7170 -- in expressions always are of the base type, not a subtype of it.
7182 -- Set overflow checking bit. Much cleverer code needed here eventually
7183 -- and perhaps the Resolve routines should be separated for the various
7184 -- arithmetic operations, since they will need different processing. ???
7193 --------------------
7194 -- Resolve_Op_Not --
7195 --------------------
7201 -- This function determines if the parent node is a boolean operator
7202 -- or operation (comparison op, membership test, or short circuit form)
7203 -- and the not in question is the left operand of this operation.
7204 -- Note that if the not is in parens, then false is returned.
7206 -----------------------
7207 -- Parent_Is_Boolean --
7208 -----------------------
7211 begin
7215 else
7217 when N_Op_And |
7218 N_Op_Eq |
7219 N_Op_Ge |
7220 N_Op_Gt |
7221 N_Op_Le |
7222 N_Op_Lt |
7223 N_Op_Ne |
7224 N_Op_Or |
7225 N_Op_Xor |
7226 N_In |
7227 N_Not_In |
7228 N_And_Then |
7229 N_Or_Else =>
7239 -- Start of processing for Resolve_Op_Not
7241 begin
7242 -- Predefined operations on scalar types yield the base type. On the
7243 -- other hand, logical operations on arrays yield the type of the
7244 -- arguments (and the context).
7248 else
7252 -- Straightforward case of incorrect arguments
7259 -- Special case of probable missing parens
7263 Error_Msg_N
7266 else
7267 Error_Msg_N
7274 -- OK resolution of not
7276 else
7277 -- Warn if non-boolean types involved. This is a case like not a < b
7278 -- where a and b are modular, where we will get (not a) < b and most
7279 -- likely not (a < b) was intended.
7281 if Warn_On_Questionable_Missing_Parens
7283 and then Parent_Is_Boolean
7284 then
7288 -- Warn on double negation if checking redundant constructs
7290 if Warn_On_Redundant_Constructs
7295 then
7299 -- Complete resolution and evaluation of NOT
7309 -----------------------------
7310 -- Resolve_Operator_Symbol --
7311 -----------------------------
7313 -- Nothing to be done, all resolved already
7319 begin
7323 ----------------------------------
7324 -- Resolve_Qualified_Expression --
7325 ----------------------------------
7333 begin
7336 -- A qualified expression requires an exact match of the type,
7337 -- class-wide matching is not allowed. However, if the qualifying
7338 -- type is specific and the expression has a class-wide type, it
7339 -- may still be okay, since it can be the result of the expansion
7340 -- of a call to a dispatching function, so we also have to check
7341 -- class-wideness of the type of the expression's original node.
7344 or else
7348 then
7352 -- If the target type is unconstrained, then we reset the type of
7353 -- the result from the type of the expression. For other cases, the
7354 -- actual subtype of the expression is the target type.
7358 then
7365 -------------------
7366 -- Resolve_Range --
7367 -------------------
7373 begin
7381 -- We have to check the bounds for being within the base range as
7382 -- required for a non-static context. Normally this is automatic and
7383 -- done as part of evaluating expressions, but the N_Range node is an
7384 -- exception, since in GNAT we consider this node to be a subexpression,
7385 -- even though in Ada it is not. The circuit in Sem_Eval could check for
7386 -- this, but that would put the test on the main evaluation path for
7387 -- expressions.
7392 -- Check for an ambiguous range over character literals. This will
7393 -- happen with a membership test involving only literals.
7401 -- If bounds are static, constant-fold them, so size computations
7402 -- are identical between front-end and back-end. Do not perform this
7403 -- transformation while analyzing generic units, as type information
7404 -- would then be lost when reanalyzing the constant node in the
7405 -- instance.
7418 --------------------------
7419 -- Resolve_Real_Literal --
7420 --------------------------
7425 begin
7426 -- Special processing for fixed-point literals to make sure that the
7427 -- value is an exact multiple of small where this is required. We
7428 -- skip this for the universal real case, and also for generic types.
7434 then
7435 declare
7442 begin
7443 -- Case of literal is not an exact multiple of the Small
7447 -- For a source program literal for a decimal fixed-point
7448 -- type, this is statically illegal (RM 4.9(36)).
7453 then
7457 -- Generate a warning if literal from source
7460 and then Warn_On_Bad_Fixed_Value
7461 then
7462 Error_Msg_N
7464 N);
7467 -- Replace literal by a value that is the exact representation
7468 -- of a value of the type, i.e. a multiple of the small value,
7469 -- by truncation, since Machine_Rounds is false for all GNAT
7470 -- fixed-point types (RM 4.9(38)).
7480 -- In all cases, set the corresponding integer field
7486 -- Now replace the actual type by the expected type as usual
7492 -----------------------
7493 -- Resolve_Reference --
7494 -----------------------
7499 begin
7500 -- Replace general access with specific type
7508 -- If we are taking the reference of a volatile entity, then treat
7509 -- it as a potential modification of this entity. This is much too
7510 -- conservative, but is necessary because remove side effects can
7511 -- result in transformations of normal assignments into reference
7512 -- sequences that otherwise fail to notice the modification.
7519 --------------------------------
7520 -- Resolve_Selected_Component --
7521 --------------------------------
7536 -- Check whether this is the initialization of a component within an
7537 -- init proc (by assignment or call to another init proc). If true,
7538 -- there is no need for a discriminant check.
7540 --------------------
7541 -- Init_Component --
7542 --------------------
7545 begin
7546 return Inside_Init_Proc
7552 -- Start of processing for Resolve_Selected_Component
7554 begin
7557 -- Use the context type to select the prefix that has a selector
7558 -- of the correct name and type.
7566 else
7572 -- The visible components of a class-wide type are those of
7573 -- the root type.
7583 then
7590 else
7594 Error_Msg_N
7599 else
7602 -- There may be an implicit dereference. Retrieve
7603 -- designated record type.
7607 else
7613 -- Resolution chooses the new interpretation.
7614 -- Find the component with the right name.
7619 loop
7641 else
7642 -- Resolve prefix with its type
7647 -- Generate cross-reference. We needed to wait until full overloading
7648 -- resolution was complete to do this, since otherwise we can't tell if
7649 -- we are an lvalue or not.
7653 else
7657 -- If prefix is an access type, the node will be transformed into an
7658 -- explicit dereference during expansion. The type of the node is the
7659 -- designated type of that of the prefix.
7664 else
7670 or else
7677 and then not Init_Component
7678 then
7686 -- If the prefix is a record conversion, this may be a renamed
7687 -- discriminant whose bounds differ from those of the original
7688 -- one, so we must ensure that a range check is performed.
7693 then
7697 -- Note: No Eval processing is required, because the prefix is of a
7698 -- record type, or protected type, and neither can possibly be static.
7702 -------------------
7703 -- Resolve_Shift --
7704 -------------------
7711 begin
7712 -- We do the resolution using the base type, because intermediate values
7713 -- in expressions always are of the base type, not a subtype of it.
7726 ---------------------------
7727 -- Resolve_Short_Circuit --
7728 ---------------------------
7735 begin
7739 -- Check for issuing warning for always False assert/check, this happens
7740 -- when assertions are turned off, in which case the pragma Assert/Check
7741 -- was transformed into:
7743 -- if False and then <condition> then ...
7745 -- and we detect this pattern
7747 if Warn_On_Assertion_Failure
7754 then
7755 declare
7758 begin
7761 then
7762 -- Don't want to warn if original condition is explicit False
7764 declare
7766 Original_Node
7767 (Expression
7769 begin
7772 then
7774 else
7775 -- Issue warning. Note that we don't want to make this
7776 -- an unconditional warning, because if the assert is
7777 -- within deleted code we do not want the warning. But
7778 -- we do not want the deletion of the IF/AND-THEN to
7779 -- take this message with it. We achieve this by making
7780 -- sure that the expanded code points to the Sloc of
7781 -- the expression, not the original pragma.
7787 -- Similar processing for Check pragma
7791 then
7792 -- Don't want to warn if original condition is explicit False
7794 declare
7796 Original_Node
7797 (Expression
7800 begin
7803 then
7805 else
7813 -- Continue with processing of short circuit
7822 -------------------
7823 -- Resolve_Slice --
7824 -------------------
7832 begin
7835 -- Use the context type to select the prefix that yields the correct
7836 -- array type.
7838 declare
7845 begin
7853 then
7861 else
7866 else
7877 else
7887 -- If the prefix is an access to an unconstrained array, we must use
7888 -- the actual subtype of the object to perform the index checks. The
7889 -- object denoted by the prefix is implicit in the node, so we build
7890 -- an explicit representation for it in order to compute the actual
7891 -- subtype.
7896 declare
7900 begin
7910 then
7913 -- If the name is a selected component that depends on discriminants,
7914 -- build an actual subtype for it. This can happen only when the name
7915 -- itself is overloaded; otherwise the actual subtype is created when
7916 -- the selected component is analyzed.
7919 and then Full_Analysis
7921 then
7922 declare
7925 begin
7930 -- Maybe this should just be "else", instead of checking for the
7931 -- specific case of slice??? This is needed for the case where
7932 -- the prefix is an Image attribute, which gets expanded to a
7933 -- slice, and so has a constrained subtype which we want to use
7934 -- for the slice range check applied below (the range check won't
7935 -- get done if the unconstrained subtype of the 'Image is used).
7941 -- If name was overloaded, set slice type correctly now
7945 -- If the range is specified by a subtype mark, no resolution is
7946 -- necessary. Else resolve the bounds, and apply needed checks.
7954 -- Do not apply the range check to nodes associated with the
7955 -- frontend expansion of the dispatch table. We first check
7956 -- if Ada.Tags is already loaded to void the addition of an
7957 -- undesired dependence on such run-time unit.
7959 and then
7961 or else not
7967 then
7982 ----------------------------
7983 -- Resolve_String_Literal --
7984 ----------------------------
7995 begin
7996 -- For a string appearing in a concatenation, defer creation of the
7997 -- string_literal_subtype until the end of the resolution of the
7998 -- concatenation, because the literal may be constant-folded away. This
7999 -- is a useful optimization for long concatenation expressions.
8001 -- If the string is an aggregate built for a single character (which
8002 -- happens in a non-static context) or a is null string to which special
8003 -- checks may apply, we build the subtype. Wide strings must also get a
8004 -- string subtype if they come from a one character aggregate. Strings
8005 -- generated by attributes might be static, but it is often hard to
8006 -- determine whether the enclosing context is static, so we generate
8007 -- subtypes for them as well, thus losing some rarer optimizations ???
8008 -- Same for strings that come from a static conversion.
8010 Need_Check :=
8019 -- If the resolving type is itself a string literal subtype, we can just
8020 -- reuse it, since there is no point in creating another.
8026 and then not Need_Check
8028 N_Attribute_Reference,
8029 N_Qualified_Expression,
8030 N_Type_Conversion)
8031 then
8034 -- Otherwise we must create a string literal subtype. Note that the
8035 -- whole idea of string literal subtypes is simply to avoid the need
8036 -- for building a full fledged array subtype for each literal.
8038 else
8044 or else Need_Check
8045 then
8052 then
8058 -- The validity of a null string has been checked in the call to
8059 -- Eval_String_Literal.
8064 -- Always accept string literal with component type Any_Character, which
8065 -- occurs in error situations and in comparisons of literals, both of
8066 -- which should accept all literals.
8071 -- If the type is bit-packed, then we always transform the string
8072 -- literal into a full fledged aggregate.
8077 -- Deal with cases of Wide_Wide_String, Wide_String, and String
8079 else
8080 -- For Standard.Wide_Wide_String, or any other type whose component
8081 -- type is Standard.Wide_Wide_Character, we know that all the
8082 -- characters in the string must be acceptable, since the parser
8083 -- accepted the characters as valid character literals.
8088 -- For the case of Standard.String, or any other type whose component
8089 -- type is Standard.Character, we must make sure that there are no
8090 -- wide characters in the string, i.e. that it is entirely composed
8091 -- of characters in range of type Character.
8093 -- If the string literal is the result of a static concatenation, the
8094 -- test has already been performed on the components, and need not be
8095 -- repeated.
8099 then
8103 -- If we are out of range, post error. This is one of the
8104 -- very few places that we place the flag in the middle of
8105 -- a token, right under the offending wide character. Not
8106 -- quite clear if this is right wrt wide character encoding
8107 -- sequences, but it's only an error message!
8109 Error_Msg
8116 -- For the case of Standard.Wide_String, or any other type whose
8117 -- component type is Standard.Wide_Character, we must make sure that
8118 -- there are no wide characters in the string, i.e. that it is
8119 -- entirely composed of characters in range of type Wide_Character.
8121 -- If the string literal is the result of a static concatenation,
8122 -- the test has already been performed on the components, and need
8123 -- not be repeated.
8127 then
8131 -- If we are out of range, post error. This is one of the
8132 -- very few places that we place the flag in the middle of
8133 -- a token, right under the offending wide character.
8135 -- This is not quite right, because characters in general
8136 -- will take more than one character position ???
8138 Error_Msg
8145 -- If the root type is not a standard character, then we will convert
8146 -- the string into an aggregate and will let the aggregate code do
8147 -- the checking. Standard Wide_Wide_Character is also OK here.
8149 else
8153 -- See if the component type of the array corresponding to the string
8154 -- has compile time known bounds. If yes we can directly check
8155 -- whether the evaluation of the string will raise constraint error.
8156 -- Otherwise we need to transform the string literal into the
8157 -- corresponding character aggregate and let the aggregate
8158 -- code do the checking.
8162 -- Check for the case of full range, where we are definitely OK
8168 -- Here the range is not the complete base type range, so check
8170 declare
8178 begin
8181 then
8187 then
8188 Apply_Compile_Time_Constraint_Error
8200 -- If we got here we meed to transform the string literal into the
8201 -- equivalent qualified positional array aggregate. This is rather
8202 -- heavy artillery for this situation, but it is hard work to avoid.
8204 declare
8209 begin
8210 -- Build the character literals, we give them source locations that
8211 -- correspond to the string positions, which is a bit tricky given
8212 -- the possible presence of wide character escape sequences.
8226 -- Should we have a call to Skip_Wide here ???
8227 -- ??? else
8228 -- Skip_Wide (P);
8236 Expression =>
8243 -----------------------------
8244 -- Resolve_Subprogram_Info --
8245 -----------------------------
8248 begin
8252 -----------------------------
8253 -- Resolve_Type_Conversion --
8254 -----------------------------
8265 begin
8266 if not Conv_OK
8268 then
8274 -- Mixed-mode operation involving a literal. Context must be a fixed
8275 -- type which is applied to the literal subsequently.
8283 or else
8285 then
8286 -- Return if expression is ambiguous
8291 -- If nothing else, the available fixed type is Duration
8293 else
8297 -- Resolve the real operand with largest available precision
8301 else
8307 -- If the operand is a literal (it could be a non-static and
8308 -- illegal exponentiation) check whether the use of Duration
8309 -- is potentially inaccurate.
8314 then
8315 Error_Msg_N
8318 Rop);
8319 Error_Msg_N
8326 then
8329 else
8338 -- Note: we do the Eval_Type_Conversion call before applying the
8339 -- required checks for a subtype conversion. This is important, since
8340 -- both are prepared under certain circumstances to change the type
8341 -- conversion to a constraint error node, but in the case of
8342 -- Eval_Type_Conversion this may reflect an illegality in the static
8343 -- case, and we would miss the illegality (getting only a warning
8344 -- message), if we applied the type conversion checks first.
8348 -- Even when evaluation is not possible, we may be able to simplify the
8349 -- conversion or its expression. This needs to be done before applying
8350 -- checks, since otherwise the checks may use the original expression
8351 -- and defeat the simplifications. This is specifically the case for
8352 -- elimination of the floating-point Truncation attribute in
8353 -- float-to-int conversions.
8357 -- If after evaluation we still have a type conversion, then we may need
8358 -- to apply checks required for a subtype conversion.
8360 -- Skip these type conversion checks if universal fixed operands
8361 -- operands involved, since range checks are handled separately for
8362 -- these cases (in the appropriate Expand routines in unit Exp_Fixd).
8368 then
8372 -- Issue warning for conversion of simple object to its own type. We
8373 -- have to test the original nodes, since they may have been rewritten
8374 -- by various optimizations.
8378 if Warn_On_Redundant_Constructs
8381 and then not In_Instance
8382 then
8386 -- If the node is part of a larger expression, the Target_Type
8387 -- may not be the original type of the node if the context is a
8388 -- condition. Recover original type to see if conversion is needed.
8392 then
8397 and then
8399 or else
8402 then
8403 -- One more check, do not give warning if the analyzed conversion
8404 -- has an expression with non-static bounds, and the bounds of the
8405 -- target are static. This avoids junk warnings in cases where the
8406 -- conversion is necessary to establish staticness, for example in
8407 -- a case statement.
8411 then
8414 -- Here we give the redundant conversion warning
8416 else
8418 Error_Msg_NE -- CODEFIX
8425 -- Ada 2005 (AI-251): Handle class-wide interface type conversions.
8426 -- No need to perform any interface conversion if the type of the
8427 -- expression coincides with the target type.
8430 and then Expander_Active
8432 then
8433 declare
8437 begin
8449 -- Conversion from interface type
8453 -- Ada 2005 (AI-217): Handle entities from limited views
8459 Error_Msg_N
8461 N);
8464 and then not
8467 then
8471 Error_Msg_N
8473 N);
8475 else
8479 -- Conversion to interface type
8483 -- Handle subtypes
8487 then
8491 if not Interface_Present_In_Ancestor
8494 then
8497 -- The static analysis is not enough to know if the
8498 -- interface is implemented or not. Hence we must pass
8499 -- the work to the expander to generate code to evaluate
8500 -- the conversion at run-time.
8504 else
8507 Error_Msg_N
8512 else
8520 ----------------------
8521 -- Resolve_Unary_Op --
8522 ----------------------
8531 begin
8532 -- Deal with intrinsic unary operators
8538 then
8543 -- Deal with universal cases
8546 or else
8548 then
8555 -- Generate warning for expressions like abs (x mod 2)
8557 if Warn_On_Redundant_Constructs
8559 then
8563 Error_Msg_N
8568 -- Deal with reference generation
8574 -- Set overflow checking bit. Much cleverer code needed here eventually
8575 -- and perhaps the Resolve routines should be separated for the various
8576 -- arithmetic operations, since they will need different processing ???
8584 -- Generate warning for expressions like -5 mod 3 for integers. No need
8585 -- to worry in the floating-point case, since parens do not affect the
8586 -- result so there is no point in giving in a warning.
8588 declare
8597 begin
8598 if Warn_On_Questionable_Missing_Parens
8602 then
8605 -- We are looking for cases where the right operand is not
8606 -- parenthesized, and is a binary operator, multiply, divide, or
8607 -- mod. These are the cases where the grouping can affect results.
8611 then
8612 -- For mod, we always give the warning, since the value is
8613 -- affected by the parenthesization (e.g. (-5) mod 315 /=
8614 -- -(5 mod 315)). But for the other cases, the only concern is
8615 -- overflow, e.g. for the case of 8 big signed (-(2 * 64)
8616 -- overflows, but (-2) * 64 does not). So we try to give the
8617 -- message only when overflow is possible.
8621 then
8626 else
8632 else
8636 -- Note that the test below is deliberately excluding the
8637 -- largest negative number, since that is a potentially
8638 -- troublesome case (e.g. -2 * x, where the result is the
8639 -- largest negative integer has an overflow with 2 * x).
8646 -- For the multiplication case, the only case we have to worry
8647 -- about is when (-a)*b is exactly the largest negative number
8648 -- so that -(a*b) can cause overflow. This can only happen if
8649 -- a is a power of 2, and more generally if any operand is a
8650 -- constant that is not a power of 2, then the parentheses
8651 -- cannot affect whether overflow occurs. We only bother to
8652 -- test the left most operand
8654 -- Loop looking at left operands for one that has known value
8661 -- Operand value of 0 or 1 skips warning
8666 -- Otherwise check power of 2, if power of 2, warn, if
8667 -- anything else, skip warning.
8669 else
8673 else
8682 -- Keep looking at left operands
8687 -- For rem or "/" we can only have a problematic situation
8688 -- if the divisor has a value of minus one or one. Otherwise
8689 -- overflow is impossible (divisor > 1) or we have a case of
8690 -- division by zero in any case.
8695 then
8699 -- If we fall through warning should be issued
8701 Error_Msg_N
8708 ----------------------------------
8709 -- Resolve_Unchecked_Expression --
8710 ----------------------------------
8712 procedure Resolve_Unchecked_Expression
8715 is
8716 begin
8721 ---------------------------------------
8722 -- Resolve_Unchecked_Type_Conversion --
8723 ---------------------------------------
8725 procedure Resolve_Unchecked_Type_Conversion
8728 is
8734 begin
8735 -- Resolve operand using its own type
8742 ------------------------------
8743 -- Rewrite_Operator_As_Call --
8744 ------------------------------
8751 begin
8758 New_N :=
8769 ------------------------------
8770 -- Rewrite_Renamed_Operator --
8771 ------------------------------
8773 procedure Rewrite_Renamed_Operator
8777 is
8782 begin
8783 -- Rewrite the operator node using the real operator, not its renaming.
8784 -- Exclude user-defined intrinsic operations of the same name, which are
8785 -- treated separately and rewritten as calls.
8789 then
8796 -- Indicate that both the original entity and its renaming are
8797 -- referenced at this point.
8808 -- If the context type is private, add the appropriate conversions
8809 -- so that the operator is applied to the full view. This is done
8810 -- in the routines that resolve intrinsic operators,
8814 then
8816 when N_Op_Add | N_Op_Subtract | N_Op_Multiply | N_Op_Divide |
8817 N_Op_Expon | N_Op_Mod | N_Op_Rem =>
8830 then
8831 -- Operator renames a user-defined operator of the same name. Use
8832 -- the original operator in the node, which is the one that Gigi
8833 -- knows about.
8840 -----------------------
8841 -- Set_Slice_Subtype --
8842 -----------------------
8844 -- Build an implicit subtype declaration to represent the type delivered
8845 -- by the slice. This is an abbreviated version of an array subtype. We
8846 -- define an index subtype for the slice, using either the subtype name
8847 -- or the discrete range of the slice. To be consistent with index usage
8848 -- elsewhere, we create a list header to hold the single index. This list
8849 -- is not otherwise attached to the syntax tree.
8860 begin
8864 else
8865 -- We force the evaluation of a range. This is definitely needed in
8866 -- the renamed case, and seems safer to do unconditionally. Note in
8867 -- any case that since we will create and insert an Itype referring
8868 -- to this range, we must make sure any side effect removal actions
8869 -- are inserted before the Itype definition.
8898 -- The Etype of the existing Slice node is reset to this slice subtype.
8899 -- Its bounds are obtained from its first index.
8903 -- In the packed case, this must be immediately frozen
8905 -- Couldn't we always freeze here??? and if we did, then the above
8906 -- call to Check_Compile_Time_Size could be eliminated, which would
8907 -- be nice, because then that routine could be made private to Freeze.
8909 -- Why the test for In_Spec_Expression here ???
8917 --------------------------------
8918 -- Set_String_Literal_Subtype --
8919 --------------------------------
8927 begin
8941 -- The low bound is set from the low bound of the corresponding
8942 -- index type. Note that we do not store the high bound in the
8943 -- string literal subtype, but it can be deduced if necessary
8944 -- from the length and the low bound.
8948 else
8949 Set_String_Literal_Low_Bound
8953 -- Build bona fide subtype for the string, and wrap it in an
8954 -- unchecked conversion, because the backend expects the
8955 -- String_Literal_Subtype to have a static lower bound.
8957 declare
8963 Right_Opnd =>
8971 begin
8972 Index_Subtype :=
8979 -- In the context, the Index_Type may already have a constraint,
8980 -- so use common base type on string subtype. The base type may
8981 -- be used when generating attributes of the string, for example
8982 -- in the context of a slice assignment.
9007 ------------------------------
9008 -- Simplify_Type_Conversion --
9009 ------------------------------
9012 begin
9014 declare
9019 begin
9021 and then
9028 -- Special processing required if the conversion is the expression
9029 -- of a Truncation attribute reference. In this case we replace:
9031 -- ityp (ftyp'Truncation (x))
9033 -- by
9035 -- ityp (x)
9037 -- with the Float_Truncate flag set, which is more efficient
9039 then
9048 -----------------------------
9049 -- Unique_Fixed_Point_Type --
9050 -----------------------------
9059 -- Give error messages for true ambiguity. Messages are posted on node
9060 -- N, and entities T1, T2 are the possible interpretations.
9062 -----------------------
9063 -- Fixed_Point_Error --
9064 -----------------------
9067 begin
9073 -- Start of processing for Unique_Fixed_Point_Type
9075 begin
9076 -- The operations on Duration are visible, so Duration is always a
9077 -- possible interpretation.
9081 -- Look for fixed-point types in enclosing scopes
9090 then
9092 Fixed_Point_Error;
9094 else
9105 -- Look for visible fixed type declarations in the context
9117 then
9119 Fixed_Point_Error;
9121 else
9135 else
9142 ----------------------
9143 -- Valid_Conversion --
9144 ----------------------
9146 function Valid_Conversion
9150 is
9154 function Conversion_Check
9157 -- Little routine to post Msg if Valid is False, returns Valid value
9159 function Valid_Tagged_Conversion
9162 -- Specifically test for validity of tagged conversions
9165 -- Check index and component conformance, and accessibility levels
9166 -- if the component types are anonymous access types (Ada 2005)
9168 ----------------------
9169 -- Conversion_Check --
9170 ----------------------
9172 function Conversion_Check
9175 is
9176 begin
9184 ----------------------------
9185 -- Valid_Array_Conversion --
9186 ----------------------------
9189 is
9204 begin
9205 -- Error if wrong number of dimensions
9207 if
9209 then
9210 Error_Msg_N
9214 -- Number of dimensions matches
9216 else
9217 -- Loop through indexes of the two arrays
9225 -- Error if index types are incompatible
9231 then
9232 Error_Msg_N
9234 Operand);
9242 -- If component types have same base type, all set
9247 -- Here if base types of components are not the same. The only
9248 -- time this is allowed is if we have anonymous access types.
9250 -- The conversion of arrays of anonymous access types can lead
9251 -- to dangling pointers. AI-392 formalizes the accessibility
9252 -- checks that must be applied to such conversions to prevent
9253 -- out-of-scope references.
9255 elsif
9257 or else
9260 and then
9262 then
9265 then
9270 Operand);
9277 -- Conversion not allowed because of accessibility levels
9279 else
9284 else
9288 -- All other cases where component base types do not match
9290 else
9291 Error_Msg_N
9293 Operand);
9297 -- Check that component subtypes statically match. For numeric
9298 -- types this means that both must be either constrained or
9299 -- unconstrained. For enumeration types the bounds must match.
9300 -- All of this is checked in Subtypes_Statically_Match.
9302 if not Subtypes_Statically_Match
9304 then
9305 Error_Msg_N
9314 -----------------------------
9315 -- Valid_Tagged_Conversion --
9316 -----------------------------
9318 function Valid_Tagged_Conversion
9321 is
9322 begin
9323 -- Upward conversions are allowed (RM 4.6(22))
9327 then
9330 -- Downward conversion are allowed if the operand is class-wide
9331 -- (RM 4.6(23)).
9335 then
9340 then
9341 return
9345 -- Ada 2005 (AI-251): The conversion to/from interface types is
9346 -- always valid
9351 -- If the operand is a class-wide type obtained through a limited_
9352 -- with clause, and the context includes the non-limited view, use
9353 -- it to determine whether the conversion is legal.
9359 then
9364 then
9367 else
9368 Error_Msg_NE
9375 -- Start of processing for Valid_Conversion
9377 begin
9381 declare
9388 begin
9389 -- Remove procedure calls, which syntactically cannot appear in
9390 -- this context, but which cannot be removed by type checking,
9391 -- because the context does not impose a type.
9393 -- When compiling for VMS, spurious ambiguities can be produced
9394 -- when arithmetic operations have a literal operand and return
9395 -- System.Address or a descendant of it. These ambiguities are
9396 -- otherwise resolved by the context, but for conversions there
9397 -- is no context type and the removal of the spurious operations
9398 -- must be done explicitly here.
9400 -- The node may be labelled overloaded, but still contain only
9401 -- one interpretation because others were discarded in previous
9402 -- filters. If this is the case, retain the single interpretation
9403 -- if legal.
9411 then
9412 -- More than one candidate interpretation is available
9422 then
9449 Error_Msg_N -- CODEFIX
9453 Error_Msg_N -- CODEFIX
9465 -- Numeric types
9469 -- A universal fixed expression can be converted to any numeric type
9474 -- Also no need to check when in an instance or inlined body, because
9475 -- the legality has been established when the template was analyzed.
9476 -- Furthermore, numeric conversions may occur where only a private
9477 -- view of the operand type is visible at the instantiation point.
9478 -- This results in a spurious error if we check that the operand type
9479 -- is a numeric type.
9481 -- Note: in a previous version of this unit, the following tests were
9482 -- applied only for generated code (Comes_From_Source set to False),
9483 -- but in fact the test is required for source code as well, since
9484 -- this situation can arise in source code.
9489 -- Otherwise we need the conversion check
9491 else
9492 return Conversion_Check
9497 -- Array types
9503 then
9504 Error_Msg_N
9507 else
9511 -- Ada 2005 (AI-251): Anonymous access types where target references an
9512 -- interface type.
9515 or else
9518 then
9519 -- Check the static accessibility rule of 4.6(17). Note that the
9520 -- check is not enforced when within an instance body, since the
9521 -- RM requires such cases to be caught at run time.
9526 then
9527 -- In an instance, this is a run-time check, but one we know
9528 -- will fail, so generate an appropriate warning. The raise
9529 -- will be generated by Expand_N_Type_Conversion.
9532 Error_Msg_N
9534 Operand);
9535 Error_Msg_N
9537 else
9538 Error_Msg_N
9540 Operand);
9544 -- Special accessibility checks are needed in the case of access
9545 -- discriminants declared for a limited type.
9549 then
9550 -- When the operand is a selected access discriminant the check
9551 -- needs to be made against the level of the object denoted by
9552 -- the prefix of the selected name (Object_Access_Level handles
9553 -- checking the prefix of the operand for this case).
9558 then
9559 -- In an instance, this is a run-time check, but one we know
9560 -- will fail, so generate an appropriate warning. The raise
9561 -- will be generated by Expand_N_Type_Conversion.
9564 Error_Msg_N
9567 Error_Msg_N
9569 else
9570 Error_Msg_N
9577 -- The case of a reference to an access discriminant from
9578 -- within a limited type declaration (which will appear as
9579 -- a discriminal) is always illegal because the level of the
9580 -- discriminant is considered to be deeper than any (nameable)
9581 -- access type.
9588 then
9589 Error_Msg_N
9591 Operand);
9599 -- General and anonymous access types
9603 and then
9604 Conversion_Check
9607 E_Access_Subprogram_Type
9609 E_Access_Protected_Subprogram_Type,
9611 then
9614 then
9615 Error_Msg_N
9620 -- Check the static accessibility rule of 4.6(17). Note that the
9621 -- check is not enforced when within an instance body, since the RM
9622 -- requires such cases to be caught at run time.
9626 then
9629 then
9630 -- In an instance, this is a run-time check, but one we know
9631 -- will fail, so generate an appropriate warning. The raise
9632 -- will be generated by Expand_N_Type_Conversion.
9635 Error_Msg_N
9637 Operand);
9638 Error_Msg_N
9641 else
9642 -- Avoid generation of spurious error message
9645 Error_Msg_N
9647 Operand);
9653 -- Special accessibility checks are needed in the case of access
9654 -- discriminants declared for a limited type.
9658 then
9660 -- When the operand is a selected access discriminant the check
9661 -- needs to be made against the level of the object denoted by
9662 -- the prefix of the selected name (Object_Access_Level handles
9663 -- checking the prefix of the operand for this case).
9668 then
9669 -- In an instance, this is a run-time check, but one we know
9670 -- will fail, so generate an appropriate warning. The raise
9671 -- will be generated by Expand_N_Type_Conversion.
9674 Error_Msg_N
9677 Error_Msg_N
9679 Operand);
9681 else
9682 Error_Msg_N
9689 -- The case of a reference to an access discriminant from
9690 -- within a limited type declaration (which will appear as
9691 -- a discriminal) is always illegal because the level of the
9692 -- discriminant is considered to be deeper than any (nameable)
9693 -- access type.
9699 then
9700 Error_Msg_N
9702 Operand);
9708 -- In the presence of limited_with clauses we have to use non-limited
9709 -- views, if available.
9713 -- Helper function to handle limited views
9715 --------------------------
9716 -- Full_Designated_Type --
9717 --------------------------
9722 begin
9723 -- Handle the limited view of a type
9728 then
9730 else
9735 -- Local Declarations
9743 -- Start of processing for Check_Limited
9745 begin
9749 else
9751 Error_Msg_NE
9756 -- Ada 2005 AI-384: legality rule is symmetric in both
9757 -- designated types. The conversion is legal (with possible
9758 -- constraint check) if either designated type is
9759 -- unconstrained.
9762 or else
9764 and then
9767 then
9768 -- Special case, if Value_Size has been used to make the
9769 -- sizes different, the conversion is not allowed even
9770 -- though the subtypes statically match.
9775 then
9776 Error_Msg_NE
9779 Error_Msg_NE
9784 -- Normal case where conversion is allowed
9786 else
9790 else
9791 Error_Msg_NE
9799 -- Access to subprogram types. If the operand is an access parameter,
9800 -- the type has a deeper accessibility that any master, and cannot
9801 -- be assigned. We must make an exception if the conversion is part
9802 -- of an assignment and the target is the return object of an extended
9803 -- return statement, because in that case the accessibility check
9804 -- takes place after the return.
9808 then
9812 and then
9816 then
9817 Error_Msg_N
9819 Operand);
9820 Error_Msg_N
9823 Operand);
9825 Error_Msg_NE
9830 -- Check that the designated types are subtype conformant
9836 -- Check the static accessibility rule of 4.6(20)
9840 then
9841 Error_Msg_N
9843 Operand);
9845 -- Check that if the operand type is declared in a generic body,
9846 -- then the target type must be declared within that same body
9847 -- (enforces last sentence of 4.6(20)).
9850 declare
9856 begin
9863 Error_Msg_N
9872 -- Remote subprogram access types
9876 then
9877 -- It is valid to convert from one RAS type to another provided
9878 -- that their specification statically match.
9880 Check_Subtype_Conformant
9883 Old_Id =>
9885 Err_Loc =>
9886 N);
9889 -- If both are tagged types, check legality of view conversions
9893 then
9896 -- Types derived from the same root type are convertible
9901 -- In an instance or an inlined body, there may be inconsistent
9902 -- views of the same type, or of types derived from a common root.
9905 and then
9908 then
9911 -- Special check for common access type error case
9915 then
9920 else