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 IType ReturnType
 214         {
 215             get { return GenericMapping.Map(Source.ReturnType); }
 216         }
 217
 218         public IParameter[] GetParameters()
 219         {
 220             return _parameters ?? (_parameters = GenericMapping.Map(Source.GetParameters()));
 221         }
 222     }
 223
 224     #endregion
 225
 226     #region class GenericMappedConstructor
 227
 228     /// <summary>
 229     /// A constructor on a generic constructed type.
 230     /// </summary>
 231     public class GenericMappedConstructor : GenericMappedMethod, IConstructor
 232     {
 233         public GenericMappedConstructor(TypeSystemServices tss, IConstructor source, GenericMapping genericMapping)
 234             : base(tss, (IMethod)source, genericMapping)
 235         {
 236         }
 237     }
 238
 239     #endregion
 240
 241     #region class GenericMappedProperty
 242
 243     /// <summary>
 244     /// A property on a generic constructed type.
 245     /// </summary>
 246     public class GenericMappedProperty : GenericMappedAccessibleMember<IProperty>, IProperty
 247     {
 248         IParameter[] _parameters;
 249
 250         public GenericMappedProperty(TypeSystemServices tss, IProperty source, GenericMapping genericMapping)
 251             : base(tss, source, genericMapping)
 252         {
 253         }
 254
 255         public IParameter[] GetParameters()
 256         {
 257             return _parameters ?? (_parameters = GenericMapping.Map(Source.GetParameters()));
 258         }
 259
 260         public IMethod GetGetMethod()
 261         {
 262             return GenericMapping.Map(Source.GetGetMethod());
 263         }
 264
 265         public IMethod GetSetMethod()
 266         {
 267             return GenericMapping.Map(Source.GetSetMethod());
 268         }
 269
 270         public override string ToString()
 271         {
 272             return string.Format("{0} as {1}", Name, Type);
 273         }
 274
 275         public bool AcceptVarArgs
 276         {
 277             get { return Source.AcceptVarArgs; }
 278         }
 279
 280         public bool IsExtension
 281         {
 282             get { return Source.IsExtension; }
 283         }
 284     }
 285
 286     #endregion
 287
 288     #region class GenericMappedEvent
 289
 290     /// <summary>
 291     /// An event in a constructed generic type.
 292     /// </summary>
 293     public class GenericMappedEvent : GenericMappedMember<IEvent>, IEvent
 294     {
 295         public GenericMappedEvent(TypeSystemServices tss, IEvent source, GenericMapping genericMapping)
 296             : base(tss, source, genericMapping)
 297         {
 298         }
 299
 300         public IMethod GetAddMethod()
 301         {
 302             return GenericMapping.Map(Source.GetAddMethod());
 303         }
 304
 305         public IMethod GetRemoveMethod()
 306         {
 307             return GenericMapping.Map(Source.GetRemoveMethod());
 308         }
 309
 310         public IMethod GetRaiseMethod()
 311         {
 312             return GenericMapping.Map(Source.GetRemoveMethod());
 313         }
 314
 315         public bool IsAbstract
 316         {
 317             get { return Source.IsAbstract; }
 318         }
 319
 320         public bool IsVirtual
 321         {
 322             get { return Source.IsVirtual; }
 323         }
 324     }
 325
 326     #endregion
 327
 328     #region class GenericMappedField
 329
 330     /// <summary>
 331     /// A field on a generic constructed type.
 332     /// </summary>
 333     public class GenericMappedField : GenericMappedAccessibleMember<IField>, IField
 334     {
 335         public GenericMappedField(TypeSystemServices tss, IField source, GenericMapping genericMapping)
 336             : base(tss, source, genericMapping)
 337         {
 338         }
 339
 340         public bool IsInitOnly
 341         {
 342             get { return Source.IsInitOnly; }
 343         }
 344
 345         public bool IsLiteral
 346         {
 347             get { return Source.IsLiteral; }
 348         }
 349
 350         public object StaticValue
 351         {
 352             get { return Source.StaticValue; }
 353         }
 354     }
 355
 356     #endregion
 357
 358     #region class GenericMappedParameter
 359
 360     /// <summary>
 361     /// A parameter in a method constructed from a generic method, or a mapped onto a type constructed
 362         /// from a generic type.
 363         /// </summary>
 364         public class GenericMappedParameter : IParameter
 365         {
 366                 private GenericMapping _genericMapping;
 367                 private IParameter _baseParameter;
 368
 369                 public GenericMappedParameter(IParameter parameter, GenericMapping genericMapping)
 370                 {
 371                         _genericMapping = genericMapping;
 372                         _baseParameter = parameter;
 373                 }
 374
 375                 public bool IsByRef
 376                 {
 377                         get { return _baseParameter.IsByRef; }
 378                 }
 379
 380                 public IType Type
 381                 {
 382                         get { return _genericMapping.Map(_baseParameter.Type); }
 383                 }
 384
 385                 public string Name
 386                 {
 387                         get { return _baseParameter.Name; }
 388                 }
 389
 390                 public string FullName
 391                 {
 392                         get { return _baseParameter.FullName; }
 393                 }
 394
 395                 public EntityType EntityType
 396                 {
 397                         get { return EntityType.Parameter; }
 398                 }
 399         }
 400
 401     #endregion
 402 }