src/Boo.Lang.Compiler/TypeSystem/GenericMappedMembers.cs

   1 #region license
   2 // Copyright (c) 2003, 2004, 2005 Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright notice,
   9 //     this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above copyright notice,
  11 //     this list of conditions and the following disclaimer in the documentation
  12 //     and/or other materials provided with the distribution.
  13 //     * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //     contributors may be used to endorse or promote products derived from this
  15 //     software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29 namespace Boo.Lang.Compiler.TypeSystem
  30 {
  31     using System;
  32     using System.Collections.Generic;
  33     using Boo.Lang.Compiler.TypeSystem;
  34     using Boo.Lang.Compiler.Ast;
  35
  36         /// <summary>
  37         /// A base class for a member mapped from a generic type onto a constructed type.
  38         /// </summary>
  39     public abstract class GenericMappedMember<T> : IMember where T : IMember
  40     {
  41         protected readonly TypeSystemServices _tss;
  42         readonly T _source;
  43         readonly GenericMapping _genericMapping;
  44         string _fullName = null;
  45
  46         protected GenericMappedMember(TypeSystemServices tss, T source, GenericMapping genericMapping)
  47         {
  48             _tss = tss;
  49             _source = source;
  50             _genericMapping = genericMapping;
  51         }
  52
  53         public T Source
  54         {
  55             get { return _source; }
  56         }
  57
  58         private string BuildFullName()
  59         {
  60             return DeclaringType.FullName + "." + Name;
  61         }
  62
  63         public GenericMapping GenericMapping
  64         {
  65             get { return _genericMapping; }
  66         }
  67
  68         public bool IsDuckTyped
  69         {
  70             get { return Source.IsDuckTyped; }
  71         }
  72
  73         public IType DeclaringType
  74         {
  75             get { return GenericMapping.Map(Source.DeclaringType); }
  76         }
  77
  78         public bool IsStatic
  79         {
  80             get { return Source.IsStatic; }
  81         }
  82
  83         public IType Type
  84         {
  85             get { return GenericMapping.Map(Source.Type); }
  86         }
  87
  88         public EntityType EntityType
  89         {
  90             get { return Source.EntityType; }
  91         }
  92
  93         public string Name
  94         {
  95             get
  96             {
  97                 return Source.Name;
  98             }
  99         }
 100
 101         public string FullName
 102         {
 103             get { return _fullName ?? (_fullName = BuildFullName()); }
 104         }
 105
 106         public bool IsPublic
 107         {
 108             get { return Source.IsPublic; }
 109         }
 110
 111                 public override string ToString()
 112                 {
 113                         return FullName;
 114                 }
 115     }
 116
 117         /// <summary>
 118         /// A base class for an accessible member mapped from a generic type onto a constructed type.
 119         /// </summary>
 120         /// <typeparam name="T"></typeparam>
 121     public abstract class GenericMappedAccessibleMember<T> : GenericMappedMember<T> where T : IAccessibleMember
 122     {
 123         protected GenericMappedAccessibleMember(TypeSystemServices tss, T source, GenericMapping genericMapping)
 124             : base(tss, source, genericMapping)
 125         {
 126         }
 127
 128         public bool IsProtected
 129         {
 130             get { return Source.IsProtected; }
 131         }
 132
 133         public bool IsInternal
 134         {
 135             get { return Source.IsInternal; }
 136         }
 137
 138         public bool IsPrivate
 139         {
 140             get { return Source.IsPrivate; }
 141         }
 142     }
 143
 144     #region class GenericMappedMethod
 145
 146     /// <summary>
 147     /// A method on a generic constructed type.
 148     /// </summary>
 149     public class GenericMappedMethod : GenericMappedAccessibleMember<IMethod>, IMethod
 150     {
 151         IParameter[] _parameters = null;
 152         ICallableType _callableType = null;
 153
 154         public GenericMappedMethod(TypeSystemServices tss, IMethod source, GenericMapping genericMapping)
 155             : base(tss, source, genericMapping)
 156         {
 157         }
 158
 159         public bool IsAbstract
 160         {
 161             get { return Source.IsAbstract; }
 162         }
 163
 164         public bool IsVirtual
 165         {
 166             get { return Source.IsVirtual; }
 167         }
 168
 169         public bool IsSpecialName
 170         {
 171             get { return Source.IsSpecialName; }
 172         }
 173
 174         public bool IsPInvoke
 175         {
 176             get { return Source.IsPInvoke; }
 177         }
 178
 179         public virtual IConstructedMethodInfo ConstructedInfo
 180         {
 181             // Generic mapped methods are not generic methods - those are InternalGenericMethods
 182             get { return null; }
 183         }
 184
 185         public IGenericMethodInfo GenericInfo
 186         {
 187             // TODO: Generic mapped methods can be generic definitions!
 188             get { return null; }
 189         }
 190
 191         public ICallableType CallableType
 192         {
 193             get
 194             {
 195                 if (null == _callableType)
 196                 {
 197                     _callableType = _tss.GetCallableType(this);
 198                 }
 199                 return _callableType;
 200             }
 201         }
 202
 203         public bool AcceptVarArgs
 204         {
 205             get { return Source.AcceptVarArgs; }
 206         }
 207
 208         public bool IsExtension
 209         {
 210             get { return Source.IsExtension; }
 211         }
 212
 213                 public bool IsBooExtension
 214                 {
 215                         get { return Source.IsBooExtension; }
 216                 }
 217
 218                 public bool IsClrExtension
 219                 {
 220                         get { return Source.IsClrExtension; }
 221                 }
 222
 223         public IType ReturnType
 224         {
 225             get { return GenericMapping.Map(Source.ReturnType); }
 226         }
 227
 228         public IParameter[] GetParameters()
 229         {
 230             return _parameters ?? (_parameters = GenericMapping.Map(Source.GetParameters()));
 231         }
 232     }
 233
 234     #endregion
 235
 236     #region class GenericMappedConstructor
 237
 238     /// <summary>
 239     /// A constructor on a generic constructed type.
 240     /// </summary>
 241     public class GenericMappedConstructor : GenericMappedMethod, IConstructor
 242     {
 243         public GenericMappedConstructor(TypeSystemServices tss, IConstructor source, GenericMapping genericMapping)
 244             : base(tss, (IMethod)source, genericMapping)
 245         {
 246         }
 247     }
 248
 249     #endregion
 250
 251     #region class GenericMappedProperty
 252
 253     /// <summary>
 254     /// A property on a generic constructed type.
 255     /// </summary>
 256     public class GenericMappedProperty : GenericMappedAccessibleMember<IProperty>, IProperty
 257     {
 258         IParameter[] _parameters;
 259
 260         public GenericMappedProperty(TypeSystemServices tss, IProperty source, GenericMapping genericMapping)
 261             : base(tss, source, genericMapping)
 262         {
 263         }
 264
 265         public IParameter[] GetParameters()
 266         {
 267             return _parameters ?? (_parameters = GenericMapping.Map(Source.GetParameters()));
 268         }
 269
 270         public IMethod GetGetMethod()
 271         {
 272             return GenericMapping.Map(Source.GetGetMethod());
 273         }
 274
 275         public IMethod GetSetMethod()
 276         {
 277             return GenericMapping.Map(Source.GetSetMethod());
 278         }
 279
 280         public override string ToString()
 281         {
 282             return string.Format("{0} as {1}", Name, Type);
 283         }
 284
 285         public bool AcceptVarArgs
 286         {
 287             get { return Source.AcceptVarArgs; }
 288         }
 289
 290         public bool IsExtension
 291         {
 292             get { return Source.IsExtension; }
 293         }
 294
 295                 public bool IsBooExtension
 296                 {
 297                         get { return Source.IsBooExtension; }
 298                 }
 299
 300                 public bool IsClrExtension
 301                 {
 302                         get { return Source.IsClrExtension; }
 303                 }
 304
 305     }
 306
 307     #endregion
 308
 309     #region class GenericMappedEvent
 310
 311     /// <summary>
 312     /// An event in a constructed generic type.
 313     /// </summary>
 314     public class GenericMappedEvent : GenericMappedMember<IEvent>, IEvent
 315     {
 316         public GenericMappedEvent(TypeSystemServices tss, IEvent source, GenericMapping genericMapping)
 317             : base(tss, source, genericMapping)
 318         {
 319         }
 320
 321         public IMethod GetAddMethod()
 322         {
 323             return GenericMapping.Map(Source.GetAddMethod());
 324         }
 325
 326         public IMethod GetRemoveMethod()
 327         {
 328             return GenericMapping.Map(Source.GetRemoveMethod());
 329         }
 330
 331         public IMethod GetRaiseMethod()
 332         {
 333             return GenericMapping.Map(Source.GetRemoveMethod());
 334         }
 335
 336         public bool IsAbstract
 337         {
 338             get { return Source.IsAbstract; }
 339         }
 340
 341         public bool IsVirtual
 342         {
 343             get { return Source.IsVirtual; }
 344         }
 345     }
 346
 347     #endregion
 348
 349     #region class GenericMappedField
 350
 351     /// <summary>
 352     /// A field on a generic constructed type.
 353     /// </summary>
 354     public class GenericMappedField : GenericMappedAccessibleMember<IField>, IField
 355     {
 356         public GenericMappedField(TypeSystemServices tss, IField source, GenericMapping genericMapping)
 357             : base(tss, source, genericMapping)
 358         {
 359         }
 360
 361         public bool IsInitOnly
 362         {
 363             get { return Source.IsInitOnly; }
 364         }
 365
 366         public bool IsLiteral
 367         {
 368             get { return Source.IsLiteral; }
 369         }
 370
 371         public object StaticValue
 372         {
 373             get { return Source.StaticValue; }
 374         }
 375     }
 376
 377     #endregion
 378
 379     #region class GenericMappedParameter
 380
 381     /// <summary>
 382     /// A parameter in a method constructed from a generic method, or a mapped onto a type constructed
 383         /// from a generic type.
 384         /// </summary>
 385         public class GenericMappedParameter : IParameter
 386         {
 387                 private GenericMapping _genericMapping;
 388                 private IParameter _baseParameter;
 389
 390                 public GenericMappedParameter(IParameter parameter, GenericMapping genericMapping)
 391                 {
 392                         _genericMapping = genericMapping;
 393                         _baseParameter = parameter;
 394                 }
 395
 396                 public bool IsByRef
 397                 {
 398                         get { return _baseParameter.IsByRef; }
 399                 }
 400
 401                 public IType Type
 402                 {
 403                         get { return _genericMapping.Map(_baseParameter.Type); }
 404                 }
 405
 406                 public string Name
 407                 {
 408                         get { return _baseParameter.Name; }
 409                 }
 410
 411                 public string FullName
 412                 {
 413                         get { return _baseParameter.FullName; }
 414                 }
 415
 416                 public EntityType EntityType
 417                 {
 418                         get { return EntityType.Parameter; }
 419                 }
 420         }
 421
 422     #endregion
 423 }