1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- S E M _ T Y P E -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2021, 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------------------------------------------------------------------------------ 25 26-- This unit contains the routines used to handle type determination, 27-- including the routine used to support overload resolution. 28 29with Types; use Types; 30 31package Sem_Type is 32 33 --------------------------------------------- 34 -- Data Structures for Overload Resolution -- 35 --------------------------------------------- 36 37 -- To determine the unique meaning of an identifier, overload resolution 38 -- may have to be performed if the visibility rules alone identify more 39 -- than one possible entity as the denotation of a given identifier. When 40 -- the visibility rules find such a potential ambiguity, the set of 41 -- possible interpretations must be attached to the identifier, and 42 -- overload resolution must be performed over the innermost enclosing 43 -- complete context. At the end of the resolution, either a single 44 -- interpretation is found for all identifiers in the context, or else a 45 -- type error (invalid type or ambiguous reference) must be signalled. 46 47 -- The set of interpretations of a given name is stored in a data structure 48 -- that is separate from the syntax tree, because it corresponds to 49 -- transient information. The interpretations themselves are stored in 50 -- table All_Interp. A mapping from tree nodes to sets of interpretations 51 -- called Interp_Map, is maintained by the overload resolution routines. 52 -- Both these structures are initialized at the beginning of every complete 53 -- context. 54 55 -- Corresponding to the set of interpretations for a given overloadable 56 -- identifier, there is a set of possible types corresponding to the types 57 -- that the overloaded call may return. We keep a 1-to-1 correspondence 58 -- between interpretations and types: for user-defined subprograms the type 59 -- is the declared return type. For operators, the type is determined by 60 -- the type of the arguments. If the arguments themselves are overloaded, 61 -- we enter the operator name in the names table for each possible result 62 -- type. In most cases, arguments are not overloaded and only one 63 -- interpretation is present anyway. 64 65 type Interp is record 66 Nam : Entity_Id; 67 Typ : Entity_Id; 68 Abstract_Op : Entity_Id := Empty; 69 end record; 70 71 -- Entity Abstract_Op is set to the abstract operation which potentially 72 -- disables the interpretation in Ada 2005 mode. 73 74 No_Interp : constant Interp := (Empty, Empty, Empty); 75 76 type Interp_Index is new Int; 77 78 --------------------- 79 -- Error Reporting -- 80 --------------------- 81 82 -- A common error is the use of an operator in infix notation on arguments 83 -- of a type that is not directly visible. Rather than diagnosing a type 84 -- mismatch, it is better to indicate that the type can be made use-visible 85 -- with the appropriate use clause. The global variable Candidate_Type is 86 -- set in Add_One_Interp whenever an interpretation might be legal for an 87 -- operator if the type were directly visible. This variable is used in 88 -- Sem_Ch4 when no legal interpretation is found. 89 90 Candidate_Type : Entity_Id; 91 92 ----------------- 93 -- Subprograms -- 94 ----------------- 95 96 procedure Init_Interp_Tables; 97 -- Initialize data structures for overload resolution 98 99 procedure Collect_Interps (N : Node_Id); 100 -- Invoked when the name N has more than one visible interpretation. This 101 -- is the high level routine which accumulates the possible interpretations 102 -- of the node. The first meaning and type of N have already been stored 103 -- in N. If the name is an expanded name, the homonyms are only those that 104 -- belong to the same scope. 105 106 function Is_Invisible_Operator (N : Node_Id; T : Entity_Id) return Boolean; 107 -- Check whether a predefined operation with universal operands appears in 108 -- a context in which the operators of the expected type are not visible. 109 110 procedure List_Interps (Nam : Node_Id; Err : Node_Id); 111 -- List candidate interpretations of an overloaded name. Used for various 112 -- error reports. 113 114 procedure Add_One_Interp 115 (N : Node_Id; 116 E : Entity_Id; 117 T : Entity_Id; 118 Opnd_Type : Entity_Id := Empty); 119 -- Add (E, T) to the list of interpretations of the node being resolved. 120 -- For calls and operators, i.e. for nodes that have a name field, E is an 121 -- overloadable entity, and T is its type. For constructs such as indexed 122 -- expressions, the caller sets E equal to T, because the overloading comes 123 -- from other fields, and the node itself has no name to resolve. Hidden 124 -- denotes whether an interpretation has been disabled by an abstract 125 -- operator. Add_One_Interp includes semantic processing to deal with 126 -- adding entries that hide one another etc. 127 -- 128 -- For operators, the legality of the operation depends on the visibility 129 -- of T and its scope. If the operator is an equality or comparison, T is 130 -- always Boolean, and we use Opnd_Type, which is a candidate type for one 131 -- of the operands of N, to check visibility. 132 133 procedure Get_First_Interp 134 (N : Node_Id; 135 I : out Interp_Index; 136 It : out Interp); 137 -- Initialize iteration over set of interpretations for Node N. The first 138 -- interpretation is placed in It, and I is initialized for subsequent 139 -- calls to Get_Next_Interp. 140 141 procedure Get_Next_Interp (I : in out Interp_Index; It : out Interp); 142 -- Iteration step over set of interpretations. Using the value in I, which 143 -- was set by a previous call to Get_First_Interp or Get_Next_Interp, the 144 -- next interpretation is placed in It, and I is updated for the next call. 145 -- The end of the list of interpretations is signalled by It.Nam = Empty. 146 147 procedure Remove_Interp (I : in out Interp_Index); 148 -- Remove an interpretation that is hidden by another, or that does not 149 -- match the context. The value of I on input was set by a call to either 150 -- Get_First_Interp or Get_Next_Interp and references the interpretation 151 -- to be removed. The only allowed use of the exit value of I is as input 152 -- to a subsequent call to Get_Next_Interp, which yields the interpretation 153 -- following the removed one. 154 155 procedure Save_Interps (Old_N : Node_Id; New_N : Node_Id); 156 -- If an overloaded node is rewritten during semantic analysis, its 157 -- possible interpretations must be linked to the copy. This procedure 158 -- transfers the overload information (Is_Overloaded flag, and list of 159 -- interpretations) from Old_N, the old node, to New_N, its new copy. 160 -- It has no effect in the non-overloaded case. 161 162 function Covers (T1, T2 : Entity_Id) return Boolean; 163 -- This is the basic type compatibility routine. T1 is the expected type, 164 -- imposed by context, and T2 is the actual type. The processing reflects 165 -- both the definition of type coverage and the rules for operand matching; 166 -- that is, this does not exactly match the RM definition of "covers". 167 168 function Disambiguate 169 (N : Node_Id; 170 I1, I2 : Interp_Index; 171 Typ : Entity_Id) return Interp; 172 -- If more than one interpretation of a name in a call is legal, apply 173 -- preference rules (universal types first) and operator visibility in 174 -- order to remove ambiguity. I1 and I2 are the first two interpretations 175 -- that are compatible with the context, but there may be others. 176 177 function Entity_Matches_Spec (Old_S, New_S : Entity_Id) return Boolean; 178 -- To resolve subprogram renaming and default formal subprograms in generic 179 -- definitions. Old_S is a possible interpretation of the entity being 180 -- renamed, New_S has an explicit signature. If Old_S is a subprogram, as 181 -- opposed to an operator, type and mode conformance are required. 182 183 function Find_Unique_Type (L : Node_Id; R : Node_Id) return Entity_Id; 184 -- Used in second pass of resolution, for equality and comparison nodes. L 185 -- is the left operand, whose type is known to be correct, and R is the 186 -- right operand, which has one interpretation compatible with that of L. 187 -- Return the type intersection of the two. 188 189 function Has_Compatible_Type 190 (N : Node_Id; 191 Typ : Entity_Id; 192 For_Comparison : Boolean := False) return Boolean; 193 -- Verify that some interpretation of the node N has a type compatible with 194 -- Typ. If N is not overloaded, then its unique type must be compatible 195 -- with Typ. Otherwise iterate through the interpretations of N looking for 196 -- a compatible one. If For_Comparison is true, the function is invoked for 197 -- a comparison (or equality) operator and also needs to verify the reverse 198 -- compatibility, because the implementation of type resolution for these 199 -- operators is not fully symmetrical. 200 201 function Hides_Op (F : Entity_Id; Op : Entity_Id) return Boolean; 202 -- A user-defined function hides a predefined operator if it matches the 203 -- signature of the operator, and is declared in an open scope, or in the 204 -- scope of the result type. 205 206 function Interface_Present_In_Ancestor 207 (Typ : Entity_Id; 208 Iface : Entity_Id) return Boolean; 209 -- Ada 2005 (AI-251): Typ must be a tagged record type/subtype and Iface 210 -- must be an abstract interface type (or a class-wide abstract interface). 211 -- This function is used to check if Typ or some ancestor of Typ implements 212 -- Iface (returning True only if so). 213 214 function Intersect_Types (L, R : Node_Id) return Entity_Id; 215 -- Find the common interpretation to two analyzed nodes. If one of the 216 -- interpretations is universal, choose the non-universal one. If either 217 -- node is overloaded, find single common interpretation. 218 219 function In_Generic_Actual (Exp : Node_Id) return Boolean; 220 -- Determine whether the expression is part of a generic actual. At the 221 -- time the actual is resolved the scope is already that of the instance, 222 -- but conceptually the resolution of the actual takes place in the 223 -- enclosing context and no special disambiguation rules should be applied. 224 225 function Is_Ancestor 226 (T1 : Entity_Id; 227 T2 : Entity_Id; 228 Use_Full_View : Boolean := False) return Boolean; 229 -- T1 is a tagged type (not class-wide). Verify that it is one of the 230 -- ancestors of type T2 (which may or not be class-wide). If Use_Full_View 231 -- is True then the full-view of private parents is used when climbing 232 -- through the parents of T2. 233 -- 234 -- Note: For analysis purposes the flag Use_Full_View must be set to False 235 -- (otherwise we break the privacy contract since this routine returns true 236 -- for hidden ancestors of private types). For expansion purposes this flag 237 -- is generally set to True since the expander must know with precision the 238 -- ancestors of a tagged type. For example, if a private type derives from 239 -- an interface type then the interface may not be an ancestor of its full 240 -- view since the full-view is only required to cover the interface (RM 7.3 241 -- (7.3/2))) and this knowledge affects construction of dispatch tables. 242 243 function Is_Progenitor 244 (Iface : Entity_Id; 245 Typ : Entity_Id) return Boolean; 246 -- Determine whether the interface Iface is implemented by Typ. It requires 247 -- traversing the list of abstract interfaces of the type, as well as that 248 -- of the ancestor types. The predicate is used to determine when a formal 249 -- in the signature of an inherited operation must carry the derived type. 250 251 function Is_Subtype_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean; 252 -- Checks whether T1 is any subtype of T2 directly or indirectly 253 254 function Operator_Matches_Spec (Op, New_S : Entity_Id) return Boolean; 255 -- Used to resolve subprograms renaming operators, and calls to user 256 -- defined operators. Determines whether a given operator Op, matches 257 -- a specification, New_S. 258 259 procedure Set_Abstract_Op (I : Interp_Index; V : Entity_Id); 260 -- Set the abstract operation field of an interpretation 261 262 function Valid_Comparison_Arg (T : Entity_Id) return Boolean; 263 -- A valid argument to an ordering operator must be a discrete type, a 264 -- real type, or a one dimensional array with a discrete component type. 265 266 function Valid_Boolean_Arg (T : Entity_Id) return Boolean; 267 -- A valid argument of a boolean operator is either some boolean type, or a 268 -- one-dimensional array of boolean type. 269 270 procedure Write_Interp (It : Interp); 271 -- Debugging procedure to display an Interp 272 273 procedure Write_Overloads (N : Node_Id); 274 -- Debugging procedure to output info on possibly overloaded entities for 275 -- specified node. 276 277end Sem_Type; 278