src/Boo.Lang.Compiler/TypeSystem/ExternalMethod.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 namespace Boo.Lang.Compiler.TypeSystem
  30 {
  31         using System;
  32         using System.Reflection;
  33
  34         public class ExternalMethod : ExternalEntity<MethodBase>, IMethod
  35         {
  36                 IParameter[] _parameters;
  37
  38                 ICallableType _type;
  39
  40                 // TODO: replace by bool?
  41                 int _acceptVarArgs = -1;
  42
  43                 int _isExtension = -1;
  44
  45                 int _isPInvoke = -1;
  46
  47                 private int _isMeta = -1;
  48
  49                 internal ExternalMethod(TypeSystemServices manager, MethodBase mi) : base(manager, mi)
  50                 {
  51                 }
  52
  53                 public bool IsMeta
  54                 {
  55                         get
  56                         {
  57                                 if (-1 == _isMeta)
  58                                 {
  59                                         _isMeta = IsStatic && MetadataUtil.IsAttributeDefined(_memberInfo, typeof(Boo.Lang.MetaAttribute))
  60                                                         ? 1
  61                                                         : 0;
  62                                 }
  63                                 return _isMeta == 1;
  64                         }
  65                 }
  66
  67                 public bool IsExtension
  68                 {
  69                         get
  70                         {
  71                                 if (-1 == _isExtension)
  72                                 {
  73                                         bool defined = MetadataUtil.IsAttributeDefined(_memberInfo, Types.BooExtensionAttribute);
  74                                         if( defined == false && MetadataUtil.HasClrExtensions())
  75                                         {
  76                                                 defined = MetadataUtil.IsAttributeDefined(_memberInfo, Types.ClrExtensionAttribute);
  77                                         }
  78                                         _isExtension = IsStatic && defined
  79                                                 ? 1
  80                                                 : 0;
  81                                 }
  82                                 return 1 == _isExtension;
  83                         }
  84                 }
  85
  86                 public bool IsPInvoke
  87                 {
  88                         get
  89                         {
  90                                 if (-1 == _isPInvoke)
  91                                 {
  92                                         _isPInvoke = IsStatic && MetadataUtil.IsAttributeDefined(_memberInfo,  Types.DllImportAttribute)
  93                                                 ? 1
  94                                                 : 0;
  95                                 }
  96                                 return 1 == _isPInvoke;
  97                         }
  98                 }
  99
 100                 public virtual IType DeclaringType
 101                 {
 102                         get
 103                         {
 104                                 return _typeSystemServices.Map(_memberInfo.DeclaringType);
 105                         }
 106                 }
 107
 108                 public bool IsStatic
 109                 {
 110                         get
 111                         {
 112                                 return _memberInfo.IsStatic;
 113                         }
 114                 }
 115
 116                 public bool IsPublic
 117                 {
 118                         get
 119                         {
 120                                 return _memberInfo.IsPublic;
 121                         }
 122                 }
 123
 124                 public bool IsProtected
 125                 {
 126                         get
 127                         {
 128                                 return _memberInfo.IsFamily || _memberInfo.IsFamilyOrAssembly;
 129                         }
 130                 }
 131
 132                 public bool IsPrivate
 133                 {
 134                         get
 135                         {
 136                                 return _memberInfo.IsPrivate;
 137                         }
 138                 }
 139
 140                 public bool IsAbstract
 141                 {
 142                         get
 143                         {
 144                                 return _memberInfo.IsAbstract;
 145                         }
 146                 }
 147
 148                 public bool IsInternal
 149                 {
 150                         get
 151                         {
 152                                 return _memberInfo.IsAssembly;
 153                         }
 154                 }
 155
 156                 public bool IsVirtual
 157                 {
 158                         get
 159                         {
 160                                 return _memberInfo.IsVirtual;
 161                         }
 162                 }
 163
 164                 public bool IsSpecialName
 165                 {
 166                         get
 167                         {
 168                                 return _memberInfo.IsSpecialName;
 169                         }
 170                 }
 171
 172                 public bool AcceptVarArgs
 173                 {
 174                         get
 175                         {
 176                                 if (_acceptVarArgs == -1)
 177                                 {
 178                                         ParameterInfo[] parameters = _memberInfo.GetParameters();
 179
 180                                         _acceptVarArgs =
 181                                                 parameters.Length > 0 && IsParamArray(parameters[parameters.Length-1]) ? 1 : 0;
 182                                 }
 183                                 return _acceptVarArgs == 1;
 184                         }
 185                 }
 186
 187                 private bool IsParamArray(ParameterInfo parameter)
 188                 {
 189                         /* Hack to fix problem with mono-1.1.8.* and older */
 190                         return parameter.ParameterType.IsArray
 191                                 && (
 192                                         Attribute.IsDefined(parameter, Types.ParamArrayAttribute)
 193                                         || parameter.GetCustomAttributes(Types.ParamArrayAttribute, false).Length > 0);
 194                 }
 195
 196
 197                 override public EntityType EntityType
 198                 {
 199                         get
 200                         {
 201                                 return EntityType.Method;
 202                         }
 203                 }
 204
 205                 public ICallableType CallableType
 206                 {
 207                         get
 208                         {
 209                                 if (null != _type) return _type;
 210
 211                 return _type = _typeSystemServices.GetCallableType(this);
 212                         }
 213                 }
 214
 215                 public IType Type
 216                 {
 217                         get
 218                         {
 219                                 return CallableType;
 220                         }
 221                 }
 222
 223                 public virtual IParameter[] GetParameters()
 224                 {
 225             if (null != _parameters) return _parameters;
 226             return _parameters = _typeSystemServices.Map(_memberInfo.GetParameters());
 227                 }
 228
 229                 public virtual IType ReturnType
 230                 {
 231                         get
 232                         {
 233                                 MethodInfo mi = _memberInfo as MethodInfo;
 234                                 if (null != mi) return _typeSystemServices.Map(mi.ReturnType);
 235                                 return null;
 236                         }
 237                 }
 238
 239                 public MethodBase MethodInfo
 240                 {
 241                         get { return _memberInfo; }
 242                 }
 243
 244                 override public bool Equals(object other)
 245                 {
 246                         ExternalMethod rhs = other as ExternalMethod;
 247                         if (null == rhs) return false;
 248                         return _memberInfo.MethodHandle.Value == rhs._memberInfo.MethodHandle.Value;
 249                 }
 250
 251                 override public int GetHashCode()
 252                 {
 253                         return _memberInfo.MethodHandle.Value.GetHashCode();
 254                 }
 255
 256                 override public string ToString()
 257                 {
 258                         return _typeSystemServices.GetSignature(this);
 259                 }
 260
 261                 ExternalGenericMethodInfo _genericMethodDefinitionInfo = null;
 262                 public IGenericMethodInfo GenericInfo
 263                 {
 264                         get
 265                         {
 266                                 if (MethodInfo.IsGenericMethodDefinition)
 267                                 {
 268                                         if (_genericMethodDefinitionInfo == null)
 269                                         {
 270                                                 _genericMethodDefinitionInfo =
 271                                                         new ExternalGenericMethodInfo(_typeSystemServices, this);
 272                                         }
 273                                         return _genericMethodDefinitionInfo;
 274                                 }
 275                                 return null;
 276                         }
 277                 }
 278
 279                 ExternalConstructedMethodInfo _genericMethodInfo = null;
 280                 public virtual IConstructedMethodInfo ConstructedInfo
 281                 {
 282                         get
 283                         {
 284                                 if (MethodInfo.IsGenericMethod)
 285                                 {
 286                                         if (_genericMethodInfo == null)
 287                                         {
 288                                                 _genericMethodInfo = new ExternalConstructedMethodInfo(_typeSystemServices, this);
 289                                         }
 290                                         return _genericMethodInfo;
 291                                 }
 292                                 return null;
 293                         }
 294                 }
 295
 296                 protected override Type MemberType
 297                 {
 298                         get
 299                         {
 300                                 MethodInfo mi = _memberInfo as MethodInfo;
 301                                 if (null != mi) return mi.ReturnType;
 302                                 return null;
 303                         }
 304                 }
 305         }
 306 }