src/Boo.Lang.Compiler/TypeSystem/InternalMethod.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 Boo.Lang.Compiler.Ast;
  33
  34         public class InternalMethod : IInternalEntity, IMethod, INamespace
  35         {
  36                 protected TypeSystemServices _typeSystemServices;
  37
  38                 protected Method _method;
  39
  40                 protected IMethod _override;
  41
  42                 protected ICallableType _type;
  43
  44                 protected IType _declaringType;
  45
  46                 protected IParameter[] _parameters;
  47
  48                 protected ExpressionCollection _returnExpressions;
  49
  50                 protected List _yieldStatements;
  51
  52                 private bool? _isBooExtension;
  53                 private bool? _isClrExtension;
  54
  55                 internal InternalMethod(TypeSystemServices typeSystemServices, Method method)
  56                 {
  57                         _typeSystemServices = typeSystemServices;
  58                         _method = method;
  59                         if (method.NodeType != NodeType.Constructor && method.NodeType != NodeType.Destructor)
  60                         {
  61                                 if (null == _method.ReturnType)
  62                                 {
  63                                         IType returnType = _method.DeclaringType.NodeType == NodeType.ClassDefinition
  64                                                 ? Unknown.Default
  65                                                 : (IType)_typeSystemServices.VoidType;
  66                                         _method.ReturnType = _typeSystemServices.CodeBuilder.CreateTypeReference(method.LexicalInfo, returnType);
  67                                 }
  68                         }
  69                 }
  70
  71                 public bool IsExtension
  72                 {
  73                         get
  74                         {
  75                                 return IsBooExtension || IsClrExtension;
  76                         }
  77                 }
  78
  79                 public bool IsBooExtension
  80                 {
  81                         get
  82                         {
  83                                 if (null == _isBooExtension)
  84                                 {
  85                                         _isBooExtension = IsAttributeDefined(Types.BooExtensionAttribute);
  86                                 }
  87                                 return _isBooExtension.Value;
  88                         }
  89                 }
  90
  91                 public bool IsClrExtension
  92                 {
  93                         get
  94                         {
  95                                 if (null == _isClrExtension)
  96                                 {
  97                                         _isClrExtension = MetadataUtil.HasClrExtensions()
  98                                                         && IsAttributeDefined(Types.ClrExtensionAttribute);
  99                                 }
 100                                 return _isClrExtension.Value;
 101                         }
 102                 }
 103
 104                 public bool IsDuckTyped
 105                 {
 106                         get
 107                         {
 108                                 return this.ReturnType == _typeSystemServices.DuckType;
 109                         }
 110                 }
 111
 112                 public bool IsPInvoke
 113                 {
 114                         get
 115                         {
 116                                 return IsAttributeDefined(Types.DllImportAttribute);
 117                         }
 118                 }
 119
 120                 private bool IsAttributeDefined(System.Type attributeType)
 121                 {
 122                         return MetadataUtil.IsAttributeDefined(_method, _typeSystemServices.Map(attributeType));
 123                 }
 124
 125                 public IType DeclaringType
 126                 {
 127                         get
 128                         {
 129                                 if (null == _declaringType)
 130                                 {
 131                                         _declaringType = (IType)TypeSystemServices.GetEntity(_method.DeclaringType);
 132                                 }
 133                                 return _declaringType;
 134                         }
 135                 }
 136
 137                 public bool IsStatic
 138                 {
 139                         get
 140                         {
 141                                 return _method.IsStatic;
 142                         }
 143                 }
 144
 145                 public bool IsPublic
 146                 {
 147                         get
 148                         {
 149                                 return _method.IsPublic;
 150                         }
 151                 }
 152
 153                 public bool IsProtected
 154                 {
 155                         get
 156                         {
 157                                 return _method.IsProtected;
 158                         }
 159                 }
 160
 161                 public bool IsPrivate
 162                 {
 163                         get
 164                         {
 165                                 return _method.IsPrivate;
 166                         }
 167                 }
 168
 169                 public bool IsInternal
 170                 {
 171                         get
 172                         {
 173                                 return _method.IsInternal;
 174                         }
 175                 }
 176
 177                 public bool IsAbstract
 178                 {
 179                         get
 180                         {
 181                                 return _method.IsAbstract;
 182                         }
 183                 }
 184
 185                 public bool IsVirtual
 186                 {
 187                         get
 188                         {
 189                                 return _method.IsVirtual
 190                                         || _method.IsAbstract
 191                                         || _method.IsOverride;
 192                         }
 193                 }
 194
 195                 public bool IsSpecialName
 196                 {
 197                         get
 198                         {
 199                                 return false;
 200                         }
 201                 }
 202
 203                 public string Name
 204                 {
 205                         get
 206                         {
 207                                 return _method.Name;
 208                         }
 209                 }
 210
 211                 public bool AcceptVarArgs
 212                 {
 213                         get
 214                         {
 215                                 return _method.Parameters.VariableNumber;
 216                         }
 217                 }
 218
 219                 public virtual string FullName
 220                 {
 221                         get
 222                         {
 223                                 return _method.DeclaringType.FullName + "." + _method.Name;
 224                         }
 225                 }
 226
 227                 public virtual EntityType EntityType
 228                 {
 229                         get
 230                         {
 231                                 return EntityType.Method;
 232                         }
 233                 }
 234
 235                 public ICallableType CallableType
 236                 {
 237                         get
 238                         {
 239                                 if (null == _type)
 240                                 {
 241                                         _type = _typeSystemServices.GetCallableType(this);
 242                                 }
 243                                 return _type;
 244                         }
 245                 }
 246
 247                 public IType Type
 248                 {
 249                         get
 250                         {
 251                                 return CallableType;
 252                         }
 253                 }
 254
 255                 public Method Method
 256                 {
 257                         get
 258                         {
 259                                 return _method;
 260                         }
 261                 }
 262
 263                 public Node Node
 264                 {
 265                         get
 266                         {
 267                                 return _method;
 268                         }
 269                 }
 270
 271                 public IMethod Overriden
 272                 {
 273                         get
 274                         {
 275                                 return _override;
 276                         }
 277
 278                         set
 279                         {
 280                                 _override = value;
 281                         }
 282                 }
 283
 284                 public IParameter[] GetParameters()
 285                 {
 286                         if (null == _parameters)
 287                         {
 288                                 _parameters = _typeSystemServices.Map(_method.Parameters);
 289                         }
 290                         return _parameters;
 291                 }
 292
 293                 public virtual IType ReturnType
 294                 {
 295                         get
 296                         {
 297                                 return TypeSystemServices.GetType(_method.ReturnType);
 298                         }
 299                 }
 300
 301                 public INamespace ParentNamespace
 302                 {
 303                         get
 304                         {
 305                                 return DeclaringType;
 306                         }
 307                 }
 308
 309                 public bool IsGenerator
 310                 {
 311                         get
 312                         {
 313                                 return null != _yieldStatements;
 314                         }
 315                 }
 316
 317                 public ExpressionCollection ReturnExpressions
 318                 {
 319                         get
 320                         {
 321                                 return _returnExpressions;
 322                         }
 323                 }
 324
 325                 public ExpressionCollection YieldExpressions
 326                 {
 327                         get
 328                         {
 329                                 ExpressionCollection expressions = new ExpressionCollection();
 330                                 foreach (YieldStatement stmt in _yieldStatements)
 331                                 {
 332                                         if (null != stmt.Expression) expressions.Add(stmt.Expression);
 333                                 }
 334                                 return expressions;
 335                         }
 336                 }
 337
 338
 339                 class LabelCollector : DepthFirstVisitor
 340                 {
 341                         public static readonly InternalLabel[] EmptyInternalLabelArray = new InternalLabel[0];
 342
 343                         protected List _labels;
 344
 345                         public override void OnLabelStatement(LabelStatement node)
 346                         {
 347                                 if (null == _labels) _labels = new List();
 348                                 _labels.Add(node.Entity);
 349                         }
 350
 351                         public InternalLabel[] Labels
 352                         {
 353                                 get
 354                                 {
 355                                         if (null == _labels) return EmptyInternalLabelArray;
 356                                         return (InternalLabel[])_labels.ToArray(new InternalLabel[_labels.Count]);
 357                                 }
 358                         }
 359                 }
 360
 361                 public InternalLabel[] Labels
 362                 {
 363                         get
 364                         {
 365                                 LabelCollector collector = new LabelCollector();
 366                                 _method.Accept(collector);
 367                                 return collector.Labels;
 368                         }
 369                 }
 370
 371                 public void AddYieldStatement(YieldStatement stmt)
 372                 {
 373                         if (null == _yieldStatements) _yieldStatements = new List();
 374                         _yieldStatements.Add(stmt);
 375                 }
 376
 377                 public void AddReturnExpression(Expression expression)
 378                 {
 379                         if (null == _returnExpressions) _returnExpressions = new ExpressionCollection();
 380                         _returnExpressions.Add(expression);
 381                 }
 382
 383                 public Local ResolveLocal(string name)
 384                 {
 385                         foreach (Local local in _method.Locals)
 386                         {
 387                                 if (local.PrivateScope) continue;
 388                                 if (name == local.Name) return local;
 389                         }
 390                         return null;
 391                 }
 392
 393                 public ParameterDeclaration ResolveParameter(string name)
 394                 {
 395                         foreach (ParameterDeclaration parameter in _method.Parameters)
 396                         {
 397                                 if (name == parameter.Name) return parameter;
 398                         }
 399                         return null;
 400                 }
 401
 402                 public virtual bool Resolve(List targetList, string name, EntityType flags)
 403                 {
 404                         if (NameResolutionService.IsFlagSet(flags, EntityType.Local))
 405                         {
 406                                 Local local = ResolveLocal(name);
 407                                 if (null != local)
 408                                 {
 409                                         targetList.Add(TypeSystemServices.GetEntity(local));
 410                                         return true;
 411                                 }
 412                         }
 413
 414                         if (NameResolutionService.IsFlagSet(flags, EntityType.Parameter))
 415                         {
 416                                 ParameterDeclaration parameter = ResolveParameter(name);
 417                                 if (null != parameter)
 418                                 {
 419                                         targetList.Add(TypeSystemServices.GetEntity(parameter));
 420                                         return true;
 421                                 }
 422                         }
 423
 424                         return false;
 425                 }
 426
 427                 IEntity[] INamespace.GetMembers()
 428                 {
 429                         return NullNamespace.EmptyEntityArray;
 430                 }
 431
 432                 override public string ToString()
 433                 {
 434                         return _typeSystemServices.GetSignature(this);
 435                 }
 436
 437                 public virtual IConstructedMethodInfo ConstructedInfo
 438                 {
 439                         get { return null; }
 440                 }
 441
 442                 public virtual IGenericMethodInfo GenericInfo
 443                 {
 444                         get { return null; }
 445                 }
 446         }
 447 }