src/Boo.Lang.Compiler/TypeSystem/GenericConstructedType.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     using System.Text;
  36
  37     /// <summary>
  38     /// A type constructed by supplying type parameters to a generic type, involving internal types.
  39     /// </summary>
  40     /// <remarks>
  41     /// Constructed types constructed from an external generic type with external type arguments
  42     /// are themselves external, and are represented as ExternalType instances. All other cases
  43     /// are represented by this type.
  44     /// </remarks>
  45     public class GenericConstructedType : IType, IConstructedTypeInfo
  46     {
  47         protected TypeSystemServices _tss;
  48         protected IType _definition;
  49         IType[] _arguments;
  50         GenericMapping _genericMapping;
  51         bool _fullyConstructed;
  52
  53         string _fullName = null;
  54
  55         public GenericConstructedType(TypeSystemServices tss, IType definition, IType[] arguments)
  56         {
  57             _tss = tss;
  58             _definition = definition;
  59             _arguments = arguments;
  60             _genericMapping = new GenericMapping(tss, this, arguments);
  61                 _fullyConstructed = IsFullyConstructed();
  62         }
  63
  64         protected bool IsFullyConstructed()
  65         {
  66                 return GenericsServices.GetTypeGenerity(this) == 0;
  67         }
  68
  69         protected string BuildFullName()
  70         {
  71             string[] argumentNames = Array.ConvertAll<IType, string>(
  72                 GenericArguments,
  73                 delegate(IType t) { return t.FullName; });
  74
  75             return string.Format("{0}[{1}]", _definition.FullName, string.Join(", ", argumentNames));
  76         }
  77
  78         public GenericMapping GenericMapping
  79         {
  80             get { return _genericMapping; }
  81         }
  82
  83         public bool IsClass
  84         {
  85             get { return _definition.IsClass; }
  86         }
  87
  88         public bool IsAbstract
  89         {
  90             get { return _definition.IsAbstract; }
  91         }
  92
  93         public bool IsInterface
  94         {
  95             get { return _definition.IsInterface; }
  96         }
  97
  98         public bool IsEnum
  99         {
 100             get { return _definition.IsEnum; }
 101         }
 102
 103         public bool IsByRef
 104         {
 105             get { return _definition.IsByRef; }
 106         }
 107
 108         public bool IsValueType
 109         {
 110             get { return _definition.IsValueType; }
 111         }
 112
 113         public bool IsFinal
 114         {
 115             get { return _definition.IsFinal; }
 116         }
 117
 118         public bool IsArray
 119         {
 120             get { return _definition.IsArray; }
 121         }
 122
 123         public int GetTypeDepth()
 124         {
 125             return _definition.GetTypeDepth();
 126         }
 127
 128         public IType GetElementType()
 129         {
 130             return GenericMapping.Map(_definition.GetElementType());
 131         }
 132
 133         public IType BaseType
 134         {
 135             get { return GenericMapping.Map(_definition.BaseType); }
 136         }
 137
 138         public IEntity GetDefaultMember()
 139         {
 140             return GenericMapping.Map(_definition.GetDefaultMember());
 141         }
 142
 143         public IConstructor[] GetConstructors()
 144         {
 145             return Array.ConvertAll<IConstructor, IConstructor>(
 146                 _definition.GetConstructors(),
 147                 delegate(IConstructor c) { return GenericMapping.Map(c); });
 148         }
 149
 150         public IType[] GetInterfaces()
 151         {
 152             return Array.ConvertAll<IType, IType>(
 153                 _definition.GetInterfaces(),
 154                 GenericMapping.Map);
 155         }
 156
 157         public bool IsSubclassOf(IType other)
 158         {
 159             if (BaseType != null && (BaseType == other || BaseType.IsSubclassOf(other)))
 160             {
 161                 return true;
 162             }
 163
 164             if (other.IsInterface && Array.Exists(
 165                 GetInterfaces(),
 166                 delegate(IType i) { return other.IsAssignableFrom(i); }))
 167             {
 168                 return true;
 169             }
 170
 171             return false;
 172         }
 173
 174         public virtual bool IsAssignableFrom(IType other)
 175         {
 176             if (other == null)
 177             {
 178                 return false;
 179             }
 180
 181             if (other == this || other.IsSubclassOf(this) || (other == Null.Default && !IsValueType))
 182             {
 183                 return true;
 184             }
 185
 186             return false;
 187         }
 188
 189         public IGenericTypeInfo GenericInfo
 190         {
 191             get { return null; }
 192         }
 193
 194         public IConstructedTypeInfo ConstructedInfo
 195         {
 196             get { return this; }
 197         }
 198
 199         public IType Type
 200         {
 201             get { return this; }
 202         }
 203
 204         public INamespace ParentNamespace
 205         {
 206             get
 207             {
 208                 return GenericMapping.Map(_definition.ParentNamespace as IEntity) as INamespace;
 209             }
 210         }
 211
 212         public bool Resolve(List targetList, string name, EntityType filter)
 213         {
 214             // Resolve name using definition, and then map the matching members
 215             List definitionMatches = new List();
 216             if (_definition.Resolve(definitionMatches, name, filter))
 217             {
 218                 foreach (IEntity match in definitionMatches)
 219                 {
 220                         if(GenericMapping.EntityNeedsMapping(match))
 221                         {
 222                         targetList.AddUnique(GenericMapping.Map(match));
 223                         }
 224                         else
 225                         {
 226                                 targetList.AddUnique(match);
 227                         }
 228                 }
 229                 return true;
 230             }
 231             return false;
 232         }
 233
 234         public IEntity[] GetMembers()
 235         {
 236             return Array.ConvertAll<IEntity, IEntity>(_definition.GetMembers(), GenericMapping.Map);
 237         }
 238
 239         public string Name
 240         {
 241             get { return _definition.Name; }
 242         }
 243
 244         public string FullName
 245         {
 246             get { return _fullName ?? (_fullName = BuildFullName()); }
 247         }
 248
 249         public EntityType EntityType
 250         {
 251             get { return EntityType.Type; }
 252         }
 253
 254         public IType[] GenericArguments
 255         {
 256             get { return _arguments; }
 257         }
 258
 259         public IType GenericDefinition
 260         {
 261             get { return _definition; }
 262         }
 263
 264         public bool FullyConstructed
 265         {
 266             get { return _fullyConstructed; }
 267         }
 268
 269         public IMethod GetMethodTemplate(IMethod method)
 270         {
 271                 return _genericMapping.UnMap(method);
 272         }
 273
 274         public override string ToString()
 275                 {
 276                         return FullName;
 277                 }
 278     }
 279
 280     public class GenericConstructedCallableType : GenericConstructedType, ICallableType
 281     {
 282         CallableSignature _signature;
 283
 284         public GenericConstructedCallableType(TypeSystemServices tss, ICallableType definition, IType[] arguments)
 285             : base(tss, definition, arguments)
 286         {
 287         }
 288
 289         public CallableSignature GetSignature()
 290         {
 291             if (_signature == null)
 292             {
 293                 CallableSignature definitionSignature = ((ICallableType)_definition).GetSignature();
 294
 295                 IParameter[] parameters = GenericMapping.Map(definitionSignature.Parameters);
 296                 IType returnType = GenericMapping.Map(definitionSignature.ReturnType);
 297
 298                 _signature = new CallableSignature(parameters, returnType);
 299             }
 300
 301             return _signature;
 302         }
 303
 304         override public bool IsAssignableFrom(IType other)
 305         {
 306             return _tss.IsCallableTypeAssignableFrom(this, other);
 307         }
 308     }
 309 }