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

   1 #region license
   2 // Copyright (c) 2004, 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 using System;
  30 using System.Reflection;
  31
  32 namespace Boo.Lang.Compiler.TypeSystem
  33 {
  34         public class ExternalProperty : ExternalEntity<System.Reflection.PropertyInfo>, IProperty
  35         {
  36                 private IParameter[] _parameters;
  37
  38                 private bool? _isBooExtension;
  39                 private bool? _isClrExtension;
  40
  41             private System.Reflection.MethodInfo _accessor = null;
  42
  43             private CachedMethod _getter = null;
  44
  45             private CachedMethod _setter = null;
  46
  47                 public ExternalProperty(TypeSystemServices typeSystemServices, System.Reflection.PropertyInfo property) : base(typeSystemServices, property)
  48                 {
  49                 }
  50
  51                 public bool IsExtension
  52                 {
  53                         get
  54                         {
  55                                 return IsBooExtension || IsClrExtension;
  56                         }
  57                 }
  58
  59                 public bool IsBooExtension
  60                 {
  61                         get
  62                         {
  63                                 if (null == _isBooExtension)
  64                                 {
  65                                         _isBooExtension = MetadataUtil.IsAttributeDefined(_memberInfo, Types.BooExtensionAttribute);
  66                                 }
  67                                 return _isBooExtension.Value;
  68                         }
  69                 }
  70
  71                 public bool IsClrExtension
  72                 {
  73                         get
  74                         {
  75                                 if (null == _isClrExtension)
  76                                 {
  77                                         _isClrExtension = MetadataUtil.HasClrExtensions()
  78                                                         && IsStatic
  79                                                         && MetadataUtil.IsAttributeDefined(_memberInfo, Types.ClrExtensionAttribute);
  80                                 }
  81                                 return _isClrExtension.Value;
  82                         }
  83                 }
  84
  85                 public virtual IType DeclaringType
  86                 {
  87                         get
  88                         {
  89                                 return _typeSystemServices.Map(_memberInfo.DeclaringType);
  90                         }
  91                 }
  92
  93                 public bool IsStatic
  94                 {
  95                         get
  96                         {
  97                                 return GetAccessor().IsStatic;
  98                         }
  99                 }
 100
 101                 public bool IsPublic
 102                 {
 103                         get
 104                         {
 105                             return GetAccessor().IsPublic;
 106                         }
 107                 }
 108
 109                 public bool IsProtected
 110                 {
 111                         get
 112                         {
 113                             System.Reflection.MethodInfo accessor = GetAccessor();
 114                 return accessor.IsFamily || accessor.IsFamilyOrAssembly;
 115                         }
 116                 }
 117
 118                 public bool IsInternal
 119                 {
 120                         get
 121                         {
 122                             return GetAccessor().IsAssembly;
 123                         }
 124                 }
 125
 126                 public bool IsPrivate
 127                 {
 128                         get
 129                         {
 130                             return GetAccessor().IsPrivate;
 131                         }
 132                 }
 133
 134                 override public EntityType EntityType
 135                 {
 136                         get
 137                         {
 138                                 return EntityType.Property;
 139                         }
 140                 }
 141
 142                 public virtual IType Type
 143                 {
 144                         get
 145                         {
 146                                 return _typeSystemServices.Map(_memberInfo.PropertyType);
 147                         }
 148                 }
 149
 150                 public System.Reflection.PropertyInfo PropertyInfo
 151                 {
 152                         get
 153                         {
 154                                 return _memberInfo;
 155                         }
 156                 }
 157
 158                 public bool AcceptVarArgs
 159                 {
 160                         get
 161                         {
 162                                 return false;
 163                         }
 164                 }
 165
 166                 protected override Type MemberType
 167                 {
 168                         get { return _memberInfo.PropertyType; }
 169                 }
 170
 171                 public virtual IParameter[] GetParameters()
 172                 {
 173             if (null != _parameters) return _parameters;
 174
 175             return _parameters = _typeSystemServices.Map(_memberInfo.GetIndexParameters());
 176                 }
 177
 178                 public virtual IMethod GetGetMethod()
 179                 {
 180             if (null != _getter) return _getter.Value;
 181                     return (_getter = new CachedMethod(FindGetMethod())).Value;
 182                 }
 183
 184             private IMethod FindGetMethod()
 185             {
 186                 System.Reflection.MethodInfo getter = _memberInfo.GetGetMethod(true);
 187             if (null == getter)
 188             {
 189                 PropertyInfo baseProperty = FindBaseProperty();
 190                 if (null == baseProperty) return null;
 191
 192                 getter = baseProperty.GetGetMethod(true);
 193                 if (null == getter) return null;
 194             }
 195                 return _typeSystemServices.Map(getter);
 196             }
 197
 198             private PropertyInfo FindBaseProperty()
 199             {
 200                 return _memberInfo.DeclaringType.BaseType.GetProperty(
 201                                                         _memberInfo.Name,
 202                                                         _memberInfo.PropertyType,
 203                                                         GetParameterTypes(_memberInfo.GetIndexParameters()));
 204             }
 205
 206             private static Type[] GetParameterTypes(ParameterInfo[] parameters)
 207             {
 208                 Type[] types = new Type[parameters.Length];
 209             for (int i=0; i<parameters.Length; ++i)
 210             {
 211                 types[i] = parameters[i].ParameterType;
 212             }
 213                 return types;
 214             }
 215
 216         public virtual IMethod GetSetMethod()
 217                 {
 218             if (null != _setter) return _setter.Value;
 219             return (_setter = new CachedMethod(FindSetMethod())).Value;
 220                 }
 221
 222             private IMethod FindSetMethod()
 223             {
 224                 System.Reflection.MethodInfo setter = _memberInfo.GetSetMethod(true);
 225                 if (null == setter) return null;
 226                 return _typeSystemServices.Map(setter);
 227             }
 228
 229                 private System.Reflection.MethodInfo GetAccessor()
 230                 {
 231             if (null != _accessor) return _accessor;
 232
 233             return _accessor = FindAccessor();
 234                 }
 235
 236             private System.Reflection.MethodInfo FindAccessor()
 237             {
 238                 System.Reflection.MethodInfo getter = _memberInfo.GetGetMethod(true);
 239                 if (null != getter) return getter;
 240                 return _memberInfo.GetSetMethod(true);
 241             }
 242         }
 243 }