src/Boo.Lang.Compiler/TypeSystem/AbstractInternalType.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.Collections;
  33         using System.Reflection;
  34         using Boo.Lang.Compiler.Ast;
  35         using Attribute = Boo.Lang.Compiler.Ast.Attribute;
  36         using System.Collections.Generic;
  37
  38         public abstract class AbstractInternalType : IInternalEntity, IType, INamespace, IGenericTypeInfo
  39         {
  40                 public static readonly IConstructor[] NoConstructors = new IConstructor[0];
  41
  42                 protected TypeSystemServices _typeSystemServices;
  43
  44                 protected TypeDefinition _typeDefinition;
  45
  46                 protected INamespace _parentNamespace;
  47
  48                 private string _fullName = null;
  49
  50                 private IGenericParameter[] _genericParameters = null;
  51
  52                 private Dictionary<IType[], IType> _constructedTypes = new Dictionary<IType[], IType>(ArrayEqualityComparer<IType>.Default);
  53
  54                 protected AbstractInternalType(TypeSystemServices typeSystemServices, TypeDefinition typeDefinition)
  55                 {
  56                         _typeSystemServices = typeSystemServices;
  57                         _typeDefinition = typeDefinition;
  58                 }
  59
  60                 protected virtual string BuildFullName()
  61                 {
  62                         string fullName = _typeDefinition.FullName;
  63
  64                         if (GenericInfo != null)
  65                         {
  66                                 fullName = string.Format("{0}`{1}", fullName, GenericInfo.GenericParameters.Length);
  67                         }
  68
  69                         return fullName;
  70                 }
  71
  72                 public string FullName
  73                 {
  74                         get { return _fullName ?? (_fullName = BuildFullName());  }
  75                 }
  76
  77                 public string Name
  78                 {
  79                         get
  80                         {
  81                                 return _typeDefinition.Name;
  82                         }
  83                 }
  84
  85                 public Node Node
  86                 {
  87                         get
  88                         {
  89                                 return _typeDefinition;
  90                         }
  91                 }
  92
  93                 public IType NestingType
  94                 {
  95                         get
  96                         {
  97                                 return _typeDefinition.ParentNode.Entity as IType;
  98                         }
  99                 }
 100
 101                 public virtual INamespace ParentNamespace
 102                 {
 103                         get
 104                         {
 105                                 if (null == _parentNamespace)
 106                                 {
 107                                         _parentNamespace = (INamespace)TypeSystemServices.GetEntity(_typeDefinition.ParentNode);
 108                                 }
 109                                 return _parentNamespace;
 110                         }
 111                 }
 112
 113                 public virtual bool Resolve(List targetList, string name, EntityType flags)
 114                 {
 115                         bool found = false;
 116
 117                         // Try to resolve name as a generic parameter
 118                         if (NameResolutionService.IsFlagSet(flags, EntityType.Type))
 119                         {
 120                                 foreach (GenericParameterDeclaration gpd in _typeDefinition.GenericParameters)
 121                                 {
 122                                         if (gpd.Name == name)
 123                                         {
 124                                                 targetList.AddUnique(gpd.Entity);
 125                                                 return true;
 126                                         }
 127                                 }
 128                         }
 129
 130                         // Try to resolve name as a member
 131                         foreach (IEntity entity in GetMembers())
 132                         {
 133                                 if (entity.Name == name && NameResolutionService.IsFlagSet(flags, entity.EntityType))
 134                                 {
 135                                         targetList.AddUnique(entity);
 136                                         found = true;
 137                                 }
 138                         }
 139
 140                         return found;
 141                 }
 142
 143                 public virtual IType BaseType
 144                 {
 145                         get
 146                         {
 147                                 return null;
 148                         }
 149                 }
 150
 151                 public TypeDefinition TypeDefinition
 152                 {
 153                         get
 154                         {
 155                                 return _typeDefinition;
 156                         }
 157                 }
 158
 159                 public IType Type
 160                 {
 161                         get
 162                         {
 163                                 return this;
 164                         }
 165                 }
 166
 167                 public bool IsByRef
 168                 {
 169                         get
 170                         {
 171                                 return false;
 172                         }
 173                 }
 174
 175                 public IType GetElementType()
 176                 {
 177                         return null;
 178                 }
 179
 180                 public bool IsClass
 181                 {
 182                         get
 183                         {
 184                                 return NodeType.ClassDefinition == _typeDefinition.NodeType;
 185                         }
 186                 }
 187
 188                 public bool IsAbstract
 189                 {
 190                         get
 191                         {
 192                                 return _typeDefinition.IsAbstract;
 193                         }
 194                 }
 195
 196                 virtual public bool IsFinal
 197                 {
 198                         get
 199                         {
 200                                 return _typeDefinition.IsFinal || IsValueType;
 201                         }
 202                 }
 203
 204                 public bool IsInterface
 205                 {
 206                         get
 207                         {
 208                                 return NodeType.InterfaceDefinition == _typeDefinition.NodeType;
 209                         }
 210                 }
 211
 212                 public bool IsEnum
 213                 {
 214                         get
 215                         {
 216                                 return NodeType.EnumDefinition == _typeDefinition.NodeType;
 217                         }
 218                 }
 219
 220                 virtual public bool IsValueType
 221                 {
 222                         get
 223                         {
 224                                 return false;
 225                         }
 226                 }
 227
 228                 public bool IsArray
 229                 {
 230                         get
 231                         {
 232                                 return false;
 233                         }
 234                 }
 235
 236                 public virtual int GetTypeDepth()
 237                 {
 238                         return 1;
 239                 }
 240
 241                 public IEntity GetDefaultMember()
 242                 {
 243                         IType defaultMemberAttribute = _typeSystemServices.Map(Types.DefaultMemberAttribute);
 244                         foreach (Attribute attribute in _typeDefinition.Attributes)
 245                         {
 246                                 IConstructor tag = TypeSystemServices.GetEntity(attribute) as IConstructor;
 247                                 if (null != tag)
 248                                 {
 249                                         if (defaultMemberAttribute == tag.DeclaringType)
 250                                         {
 251                                                 StringLiteralExpression memberName = attribute.Arguments[0] as StringLiteralExpression;
 252                                                 if (null != memberName)
 253                                                 {
 254                                                         List buffer = new List();
 255                                                         Resolve(buffer, memberName.Value, EntityType.Any);
 256                                                         return NameResolutionService.GetEntityFromList(buffer);
 257                                                 }
 258                                         }
 259                                 }
 260                         }
 261                         if (_typeDefinition.BaseTypes.Count > 0)
 262                         {
 263                                 List buffer = new List();
 264
 265                                 foreach (TypeReference baseType in _typeDefinition.BaseTypes)
 266                                 {
 267                                         IType tag = TypeSystemServices.GetType(baseType);
 268                                         IEntity defaultMember = tag.GetDefaultMember();
 269                                         if (defaultMember != null)
 270                                         {
 271                                                 if (tag.IsInterface)
 272                                                 {
 273                                                         buffer.AddUnique(defaultMember);
 274                                                 }
 275                                                 else //non-interface base class trumps interfaces
 276                                                 {
 277                                                         return defaultMember;
 278                                                 }
 279                                         }
 280                                 }
 281                                 return NameResolutionService.GetEntityFromList(buffer);
 282                         }
 283                         return null;
 284                 }
 285
 286                 public virtual EntityType EntityType
 287                 {
 288                         get
 289                         {
 290                                 return EntityType.Type;
 291                         }
 292                 }
 293
 294                 public virtual bool IsSubclassOf(IType other)
 295                 {
 296                         return false;
 297                 }
 298
 299                 public virtual bool IsAssignableFrom(IType other)
 300                 {
 301                         return this == other ||
 302                                         (!this.IsValueType && Null.Default == other) ||
 303                                         other.IsSubclassOf(this);
 304                 }
 305
 306                 public virtual IConstructor[] GetConstructors()
 307                 {
 308                         return NoConstructors;
 309                 }
 310
 311                 public IType[] GetInterfaces()
 312                 {
 313                         List buffer = new List(_typeDefinition.BaseTypes.Count);
 314                         foreach (TypeReference baseType in _typeDefinition.BaseTypes)
 315                         {
 316                                 IType type = TypeSystemServices.GetType(baseType);
 317                                 if (type.IsInterface) buffer.AddUnique(type);
 318                         }
 319                         return (IType[])buffer.ToArray(new IType[buffer.Count]);
 320                 }
 321
 322                 public virtual IEntity[] GetMembers()
 323                 {
 324                         return GetMemberEntities(_typeDefinition.Members);
 325                 }
 326
 327                 private IEntity[] GetMemberEntities(TypeMemberCollection members)
 328                 {
 329                         IEntity[] entities = new IEntity[members.Count];
 330                         for (int i = 0; i < entities.Length; ++i)
 331                         {
 332                                 entities[i] = _typeSystemServices.GetMemberEntity(members[i]);
 333                         }
 334                         return entities;
 335                 }
 336
 337
 338                 override public string ToString()
 339                 {
 340                         return FullName;
 341                 }
 342
 343                 public IGenericTypeInfo GenericInfo
 344                 {
 345                         get
 346                         {
 347                                 if (TypeDefinition.GenericParameters.Count != 0)
 348                                 {
 349                                         return this;
 350                                 }
 351                                 return null;
 352                         }
 353                 }
 354
 355                 public IConstructedTypeInfo ConstructedInfo
 356                 {
 357                         get { return null; }
 358                 }
 359
 360                 IGenericParameter[] IGenericTypeInfo.GenericParameters
 361                 {
 362                         get
 363                         {
 364                                 if (_genericParameters == null)
 365                                 {
 366                                         _genericParameters = Array.ConvertAll<GenericParameterDeclaration, IGenericParameter>(
 367                                                 _typeDefinition.GenericParameters.ToArray(),
 368                                                 delegate(GenericParameterDeclaration gpd) { return (IGenericParameter)gpd.Entity; } );
 369                                 }
 370
 371                                 return _genericParameters;
 372                         }
 373                 }
 374
 375                 IType IGenericTypeInfo.ConstructType(IType[] arguments)
 376                 {
 377                         IType constructed = null;
 378                         if (!_constructedTypes.TryGetValue(arguments, out constructed))
 379                         {
 380                                 constructed = CreateConstructedType(arguments);
 381                                 _constructedTypes.Add(arguments, constructed);
 382                         }
 383
 384                         return constructed;
 385                 }
 386
 387                 protected virtual IType CreateConstructedType(IType[] arguments)
 388                 {
 389                         return new GenericConstructedType(_typeSystemServices, this, arguments);
 390                 }
 391         }
 392
 393 }