mcs/mcs/typemanager.cs

   1 //
   2 // typemanager.cs: C# type manager
   3 //
   4 // Author: Miguel de Icaza (miguel@gnu.org)
   5 //         Ravi Pratap     (ravi@ximian.com)
   6 //         Marek Safar     (marek.safar@seznam.cz)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2003-2008 Novell, Inc.
  12 //
  13
  14 using System;
  15 using System.IO;
  16 using System.Globalization;
  17 using System.Collections.Generic;
  18 using System.Reflection;
  19 using System.Reflection.Emit;
  20 using System.Text;
  21 using System.Runtime.CompilerServices;
  22 using System.Diagnostics;
  23 using System.Linq;
  24
  25 namespace Mono.CSharp {
  26
  27         partial class TypeManager {
  28         //
  29         // A list of core types that the compiler requires or uses
  30         //
  31         static public PredefinedTypeSpec object_type;
  32         static public PredefinedTypeSpec value_type;
  33         static public PredefinedTypeSpec string_type;
  34         static public PredefinedTypeSpec int32_type;
  35         static public PredefinedTypeSpec uint32_type;
  36         static public PredefinedTypeSpec int64_type;
  37         static public PredefinedTypeSpec uint64_type;
  38         static public PredefinedTypeSpec float_type;
  39         static public PredefinedTypeSpec double_type;
  40         static public PredefinedTypeSpec char_type;
  41         static public PredefinedTypeSpec short_type;
  42         static public PredefinedTypeSpec decimal_type;
  43         static public PredefinedTypeSpec bool_type;
  44         static public PredefinedTypeSpec sbyte_type;
  45         static public PredefinedTypeSpec byte_type;
  46         static public PredefinedTypeSpec ushort_type;
  47         static public PredefinedTypeSpec enum_type;
  48         static public PredefinedTypeSpec delegate_type;
  49         static public PredefinedTypeSpec multicast_delegate_type;
  50         static public PredefinedTypeSpec void_type;
  51         static public PredefinedTypeSpec array_type;
  52         static public PredefinedTypeSpec runtime_handle_type;
  53         static public PredefinedTypeSpec type_type;
  54         static public PredefinedTypeSpec ienumerator_type;
  55         static public PredefinedTypeSpec ienumerable_type;
  56         static public PredefinedTypeSpec idisposable_type;
  57         static public PredefinedTypeSpec intptr_type;
  58         static public PredefinedTypeSpec uintptr_type;
  59         static public PredefinedTypeSpec runtime_field_handle_type;
  60         static public PredefinedTypeSpec attribute_type;
  61         static public PredefinedTypeSpec exception_type;
  62
  63
  64         static public TypeSpec typed_reference_type;
  65         static public TypeSpec arg_iterator_type;
  66         static public TypeSpec mbr_type;
  67         public static TypeSpec runtime_helpers_type;
  68         static public TypeSpec iasyncresult_type;
  69         static public TypeSpec asynccallback_type;
  70         static public TypeSpec runtime_argument_handle_type;
  71         static public TypeSpec void_ptr_type;
  72
  73         //
  74         // C# 2.0
  75         //
  76         static internal TypeSpec isvolatile_type;
  77         static public TypeSpec generic_ilist_type;
  78         static public TypeSpec generic_icollection_type;
  79         static public TypeSpec generic_ienumerator_type;
  80         static public TypeSpec generic_ienumerable_type;
  81         static public TypeSpec generic_nullable_type;
  82
  83         //
  84         // C# 3.0
  85         //
  86         static internal TypeSpec expression_type;
  87         public static TypeSpec parameter_expression_type;
  88         public static TypeSpec fieldinfo_type;
  89         public static TypeSpec methodinfo_type;
  90         public static TypeSpec ctorinfo_type;
  91
  92         //
  93         // C# 4.0
  94         //
  95         public static TypeSpec call_site_type;
  96         public static TypeSpec generic_call_site_type;
  97         public static TypeExpr binder_type;
  98         public static TypeSpec binder_flags;
  99
 100         public static TypeExpr expression_type_expr;
 101
 102
 103         //
 104         // These methods are called by code generated by the compiler
 105         //
 106         static public FieldSpec string_empty;
 107         static public MethodSpec system_type_get_type_from_handle;
 108         static public MethodSpec bool_movenext_void;
 109         static public MethodSpec void_dispose_void;
 110         static public MethodSpec void_monitor_enter_object;
 111         static public MethodSpec void_monitor_exit_object;
 112         static public MethodSpec void_initializearray_array_fieldhandle;
 113         static public MethodSpec delegate_combine_delegate_delegate;
 114         static public MethodSpec delegate_remove_delegate_delegate;
 115         static public PropertySpec int_get_offset_to_string_data;
 116         static public MethodSpec int_interlocked_compare_exchange;
 117         static public PropertySpec ienumerator_getcurrent;
 118         public static MethodSpec methodbase_get_type_from_handle;
 119         public static MethodSpec methodbase_get_type_from_handle_generic;
 120         public static MethodSpec fieldinfo_get_field_from_handle;
 121         public static MethodSpec fieldinfo_get_field_from_handle_generic;
 122         public static MethodSpec activator_create_instance;
 123
 124         //
 125         // The constructors.
 126         //
 127         static public MethodSpec void_decimal_ctor_five_args;
 128         static public MethodSpec void_decimal_ctor_int_arg;
 129         public static MethodSpec void_decimal_ctor_long_arg;
 130
 131         static Dictionary<Assembly, bool> assembly_internals_vis_attrs;
 132
 133         static TypeManager ()
 134         {
 135                 Reset ();
 136         }
 137
 138         static public void Reset ()
 139         {
 140 //              object_type = null;
 141
 142                 assembly_internals_vis_attrs = new Dictionary<Assembly, bool> ();
 143
 144                 // TODO: I am really bored by all this static stuff
 145                 system_type_get_type_from_handle =
 146                 bool_movenext_void =
 147                 void_dispose_void =
 148                 void_monitor_enter_object =
 149                 void_monitor_exit_object =
 150                 void_initializearray_array_fieldhandle =
 151                 int_interlocked_compare_exchange =
 152                 methodbase_get_type_from_handle =
 153                 methodbase_get_type_from_handle_generic =
 154                 fieldinfo_get_field_from_handle =
 155                 fieldinfo_get_field_from_handle_generic =
 156                 activator_create_instance =
 157                 delegate_combine_delegate_delegate =
 158                 delegate_remove_delegate_delegate = null;
 159
 160                 int_get_offset_to_string_data =
 161                 ienumerator_getcurrent = null;
 162
 163                 void_decimal_ctor_five_args =
 164                 void_decimal_ctor_int_arg =
 165                 void_decimal_ctor_long_arg = null;
 166
 167                 string_empty = null;
 168
 169                 call_site_type =
 170                 generic_call_site_type =
 171                 binder_flags = null;
 172
 173                 binder_type = null;
 174
 175                 typed_reference_type = arg_iterator_type = mbr_type =
 176                 runtime_helpers_type = iasyncresult_type = asynccallback_type =
 177                 runtime_argument_handle_type = void_ptr_type = isvolatile_type =
 178                 generic_ilist_type = generic_icollection_type = generic_ienumerator_type =
 179                 generic_ienumerable_type = generic_nullable_type = expression_type =
 180                 parameter_expression_type = fieldinfo_type = methodinfo_type = ctorinfo_type = null;
 181
 182                 expression_type_expr = null;
 183         }
 184
 185         /// <summary>
 186         ///   Returns the C# name of a type if possible, or the full type name otherwise
 187         /// </summary>
 188         static public string CSharpName (TypeSpec t)
 189         {
 190                 return t.GetSignatureForError ();
 191         }
 192
 193         static public string CSharpName (IList<TypeSpec> types)
 194         {
 195                 if (types.Count == 0)
 196                         return string.Empty;
 197
 198                 StringBuilder sb = new StringBuilder ();
 199                 for (int i = 0; i < types.Count; ++i) {
 200                         if (i > 0)
 201                                 sb.Append (",");
 202
 203                         sb.Append (CSharpName (types [i]));
 204                 }
 205                 return sb.ToString ();
 206         }
 207
 208         static public string GetFullNameSignature (MemberSpec mi)
 209         {
 210                 return mi.GetSignatureForError ();
 211         }
 212
 213         static public string CSharpSignature (MemberSpec mb)
 214         {
 215                 return mb.GetSignatureForError ();
 216         }
 217
 218         //
 219         // Looks up a type, and aborts if it is not found.  This is used
 220         // by predefined types required by the compiler
 221         //
 222         public static TypeSpec CoreLookupType (CompilerContext ctx, string ns_name, string name, MemberKind kind, bool required)
 223         {
 224                 return CoreLookupType (ctx, ns_name, name, 0, kind, required);
 225         }
 226
 227         public static TypeSpec CoreLookupType (CompilerContext ctx, string ns_name, string name, int arity, MemberKind kind, bool required)
 228         {
 229                 Namespace ns = GlobalRootNamespace.Instance.GetNamespace (ns_name, true);
 230                 var te = ns.LookupType (ctx, name, arity, !required, Location.Null);
 231                 var ts = te == null ? null : te.Type;
 232
 233                 if (!required)
 234                         return ts;
 235
 236                 if (ts == null) {
 237                         ctx.Report.Error (518, "The predefined type `{0}.{1}' is not defined or imported",
 238                                 ns_name, name);
 239                         return null;
 240                 }
 241
 242                 if (ts.Kind != kind) {
 243                         ctx.Report.Error (520, "The predefined type `{0}.{1}' is not declared correctly",
 244                                 ns_name, name);
 245                         return null;
 246                 }
 247
 248                 return ts;
 249         }
 250
 251         static MemberSpec GetPredefinedMember (TypeSpec t, MemberFilter filter, Location loc)
 252         {
 253                 var member = MemberCache.FindMember (t, filter, BindingRestriction.DeclaredOnly);
 254
 255                 if (member != null && member.IsAccessible (InternalType.FakeInternalType))
 256                         return member;
 257
 258                 string method_args = null;
 259                 if (filter.Parameters != null)
 260                         method_args = filter.Parameters.GetSignatureForError ();
 261
 262                 RootContext.ToplevelTypes.Compiler.Report.Error (656, loc, "The compiler required member `{0}.{1}{2}' could not be found or is inaccessible",
 263                         TypeManager.CSharpName (t), filter.Name, method_args);
 264
 265                 return null;
 266         }
 267
 268         //
 269         // Returns the ConstructorInfo for "args"
 270         //
 271         public static MethodSpec GetPredefinedConstructor (TypeSpec t, Location loc, params TypeSpec [] args)
 272         {
 273                 var pc = ParametersCompiled.CreateFullyResolved (args);
 274                 return GetPredefinedMember (t, MemberFilter.Constructor (pc), loc) as MethodSpec;
 275         }
 276
 277         //
 278         // Returns the method specification for a method named `name' defined
 279         // in type `t' which takes arguments of types `args'
 280         //
 281         public static MethodSpec GetPredefinedMethod (TypeSpec t, string name, Location loc, params TypeSpec [] args)
 282         {
 283                 var pc = ParametersCompiled.CreateFullyResolved (args);
 284                 return GetPredefinedMethod (t, MemberFilter.Method (name, 0, pc, null), loc);
 285         }
 286
 287         public static MethodSpec GetPredefinedMethod (TypeSpec t, MemberFilter filter, Location loc)
 288         {
 289                 return GetPredefinedMember (t, filter, loc) as MethodSpec;
 290         }
 291
 292         public static FieldSpec GetPredefinedField (TypeSpec t, string name, Location loc, TypeSpec type)
 293         {
 294                 return GetPredefinedMember (t, MemberFilter.Field (name, type), loc) as FieldSpec;
 295         }
 296
 297         public static PropertySpec GetPredefinedProperty (TypeSpec t, string name, Location loc, TypeSpec type)
 298         {
 299                 return GetPredefinedMember (t, MemberFilter.Property (name, type), loc) as PropertySpec;
 300         }
 301
 302         public static IList<PredefinedTypeSpec> InitCoreTypes ()
 303         {
 304                 var core_types = new PredefinedTypeSpec[] {
 305                         object_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Object"),
 306                         value_type = new PredefinedTypeSpec (MemberKind.Class, "System", "ValueType"),
 307                         attribute_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Attribute"),
 308
 309                         int32_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int32"),
 310                         int64_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int64"),
 311                         uint32_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt32"),
 312                         uint64_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt64"),
 313                         byte_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Byte"),
 314                         sbyte_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "SByte"),
 315                         short_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Int16"),
 316                         ushort_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UInt16"),
 317
 318                         ienumerator_type = new PredefinedTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerator"),
 319                         ienumerable_type = new PredefinedTypeSpec (MemberKind.Interface, "System.Collections", "IEnumerable"),
 320                         idisposable_type = new PredefinedTypeSpec (MemberKind.Interface, "System", "IDisposable"),
 321
 322                         char_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Char"),
 323                         string_type = new PredefinedTypeSpec (MemberKind.Class, "System", "String"),
 324                         float_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Single"),
 325                         double_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Double"),
 326                         decimal_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Decimal"),
 327                         bool_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Boolean"),
 328                         intptr_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "IntPtr"),
 329                         uintptr_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "UIntPtr"),
 330
 331                         multicast_delegate_type = new PredefinedTypeSpec (MemberKind.Class, "System", "MulticastDelegate"),
 332                         delegate_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Delegate"),
 333                         enum_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Enum"),
 334                         array_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Array"),
 335                         void_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "Void"),
 336                         type_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Type"),
 337                         exception_type = new PredefinedTypeSpec (MemberKind.Class, "System", "Exception"),
 338                         runtime_field_handle_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "RuntimeFieldHandle"),
 339                         runtime_handle_type = new PredefinedTypeSpec (MemberKind.Struct, "System", "RuntimeTypeHandle"),
 340                 };
 341
 342                 return core_types;
 343         }
 344
 345         /// <remarks>
 346         ///   The types have to be initialized after the initial
 347         ///   population of the type has happened (for example, to
 348         ///   bootstrap the corlib.dll
 349         /// </remarks>
 350         public static bool InitCoreTypes (CompilerContext ctx, IList<PredefinedTypeSpec> predefined)
 351         {
 352                 foreach (var p in predefined) {
 353                         var found = CoreLookupType (ctx, p.Namespace, p.Name, p.Kind, true);
 354                         if (found == null || found == p)
 355                                 continue;
 356
 357                         if (!RootContext.StdLib) {
 358                                 var ns = GlobalRootNamespace.Instance.GetNamespace (p.Namespace, false);
 359                                 ns.ReplaceTypeWithPredefined (found, p);
 360
 361                                 var tc = found.MemberDefinition as TypeContainer;
 362                                 tc.SetPredefinedSpec (p);
 363                                 p.SetDefinition (found);
 364                         }
 365                 }
 366
 367                 PredefinedAttributes.Get.ParamArray.Initialize (ctx, false);
 368                 PredefinedAttributes.Get.Out.Initialize (ctx, false);
 369
 370                 if (InternalType.Dynamic.GetMetaInfo () == null) {
 371                         InternalType.Dynamic.SetMetaInfo (object_type.GetMetaInfo ());
 372                         InternalType.Dynamic.MemberCache = object_type.MemberCache;
 373
 374                         InternalType.Null.SetMetaInfo (object_type.GetMetaInfo ());
 375                 }
 376
 377                 return ctx.Report.Errors == 0;
 378         }
 379
 380         //
 381         // Initializes optional core types
 382         //
 383         public static void InitOptionalCoreTypes (CompilerContext ctx)
 384         {
 385                 void_ptr_type = PointerContainer.MakeType (void_type);
 386
 387                 //
 388                 // Initialize InternalsVisibleTo as the very first optional type. Otherwise we would populate
 389                 // types cache with incorrect accessiblity when any of optional types is internal.
 390                 //
 391                 PredefinedAttributes.Get.Initialize (ctx);
 392
 393                 runtime_argument_handle_type = CoreLookupType (ctx, "System", "RuntimeArgumentHandle", MemberKind.Struct, false);
 394                 asynccallback_type = CoreLookupType (ctx, "System", "AsyncCallback", MemberKind.Delegate, false);
 395                 iasyncresult_type = CoreLookupType (ctx, "System", "IAsyncResult", MemberKind.Interface, false);
 396                 typed_reference_type = CoreLookupType (ctx, "System", "TypedReference", MemberKind.Struct, false);
 397                 arg_iterator_type = CoreLookupType (ctx, "System", "ArgIterator", MemberKind.Struct, false);
 398                 mbr_type = CoreLookupType (ctx, "System", "MarshalByRefObject", MemberKind.Class, false);
 399
 400                 generic_ienumerator_type = CoreLookupType (ctx, "System.Collections.Generic", "IEnumerator", 1, MemberKind.Interface, false);
 401                 generic_ilist_type = CoreLookupType (ctx, "System.Collections.Generic", "IList", 1, MemberKind.Interface, false);
 402                 generic_icollection_type = CoreLookupType (ctx, "System.Collections.Generic", "ICollection", 1, MemberKind.Interface, false);
 403                 generic_ienumerable_type = CoreLookupType (ctx, "System.Collections.Generic", "IEnumerable", 1, MemberKind.Interface, false);
 404                 generic_nullable_type = CoreLookupType (ctx, "System", "Nullable", 1, MemberKind.Struct, false);
 405
 406                 //
 407                 // Optional types which are used as types and for member lookup
 408                 //
 409                 runtime_helpers_type = CoreLookupType (ctx, "System.Runtime.CompilerServices", "RuntimeHelpers", MemberKind.Class, false);
 410
 411                 // New in .NET 3.5
 412                 // Note: extension_attribute_type is already loaded
 413                 expression_type = CoreLookupType (ctx, "System.Linq.Expressions", "Expression", 1, MemberKind.Class, false);
 414         }
 415
 416         public static bool IsBuiltinType (TypeSpec t)
 417         {
 418                 if (t == object_type || t == string_type || t == int32_type || t == uint32_type ||
 419                     t == int64_type || t == uint64_type || t == float_type || t == double_type ||
 420                     t == char_type || t == short_type || t == decimal_type || t == bool_type ||
 421                     t == sbyte_type || t == byte_type || t == ushort_type || t == void_type)
 422                         return true;
 423                 else
 424                         return false;
 425         }
 426
 427         //
 428         // This is like IsBuiltinType, but lacks decimal_type, we should also clean up
 429         // the pieces in the code where we use IsBuiltinType and special case decimal_type.
 430         //
 431         public static bool IsPrimitiveType (TypeSpec t)
 432         {
 433                 return (t == int32_type || t == uint32_type ||
 434                     t == int64_type || t == uint64_type || t == float_type || t == double_type ||
 435                     t == char_type || t == short_type || t == bool_type ||
 436                     t == sbyte_type || t == byte_type || t == ushort_type);
 437         }
 438
 439         // Obsolete
 440         public static bool IsDelegateType (TypeSpec t)
 441         {
 442                 return t.IsDelegate;
 443         }
 444
 445         //
 446         // When any element of the type is a dynamic type
 447         //
 448         // This method builds a transformation array for dynamic types
 449         // used in places where DynamicAttribute cannot be applied to.
 450         // It uses bool flag when type is of dynamic type and each
 451         // section always starts with "false" for some reason.
 452         //
 453         // LAMESPEC: This should be part of C# specification !
 454         //
 455         // Example: Func<dynamic, int, dynamic[]>
 456         // Transformation: { false, true, false, false, true }
 457         //
 458         public static bool[] HasDynamicTypeUsed (TypeSpec t)
 459         {
 460                 var ac = t as ArrayContainer;
 461                 if (ac != null) {
 462                         if (HasDynamicTypeUsed (ac.Element) != null)
 463                                 return new bool[] { false, true };
 464
 465                         return null;
 466                 }
 467
 468                 if (t == null)
 469                         return null;
 470
 471                 if (IsGenericType (t)) {
 472                         List<bool> transform = null;
 473                         var targs = GetTypeArguments (t);
 474                         for (int i = 0; i < targs.Length; ++i) {
 475                                 var element = HasDynamicTypeUsed (targs [i]);
 476                                 if (element != null) {
 477                                         if (transform == null) {
 478                                                 transform = new List<bool> ();
 479                                                 for (int ii = 0; ii <= i; ++ii)
 480                                                         transform.Add (false);
 481                                         }
 482
 483                                         transform.AddRange (element);
 484                                 } else if (transform != null) {
 485                                         transform.Add (false);
 486                                 }
 487                         }
 488
 489                         if (transform != null)
 490                                 return transform.ToArray ();
 491                 }
 492
 493                 if (object.ReferenceEquals (InternalType.Dynamic, t))
 494                         return new bool [] { true };
 495
 496                 return null;
 497         }
 498
 499         // Obsolete
 500         public static bool IsEnumType (TypeSpec t)
 501         {
 502                 return t.IsEnum;
 503         }
 504
 505         public static bool IsBuiltinOrEnum (TypeSpec t)
 506         {
 507                 if (IsBuiltinType (t))
 508                         return true;
 509
 510                 if (IsEnumType (t))
 511                         return true;
 512
 513                 return false;
 514         }
 515
 516         //
 517         // Whether a type is unmanaged.  This is used by the unsafe code (25.2)
 518         //
 519         public static bool IsUnmanagedType (TypeSpec t)
 520         {
 521                 var ds = t.MemberDefinition as DeclSpace;
 522                 if (ds != null)
 523                         return ds.IsUnmanagedType ();
 524
 525                 // some builtins that are not unmanaged types
 526                 if (t == TypeManager.object_type || t == TypeManager.string_type)
 527                         return false;
 528
 529                 if (IsBuiltinOrEnum (t))
 530                         return true;
 531
 532                 // Someone did the work of checking if the ElementType of t is unmanaged.  Let's not repeat it.
 533                 if (t.IsPointer)
 534                         return IsUnmanagedType (GetElementType (t));
 535
 536                 if (!IsValueType (t))
 537                         return false;
 538
 539                 if (t.IsNested && t.DeclaringType.IsGenericOrParentIsGeneric)
 540                         return false;
 541
 542                 return true;
 543         }
 544
 545         //
 546         // Null is considered to be a reference type
 547         //
 548         public static bool IsReferenceType (TypeSpec t)
 549         {
 550                 if (t.IsGenericParameter)
 551                         return ((TypeParameterSpec) t).IsReferenceType;
 552
 553                 return !t.IsStruct && !IsEnumType (t);
 554         }
 555
 556         public static bool IsValueType (TypeSpec t)
 557         {
 558                 if (t.IsGenericParameter)
 559                         return ((TypeParameterSpec) t).IsValueType;
 560
 561                 return t.IsStruct || IsEnumType (t);
 562         }
 563
 564         public static bool IsStruct (TypeSpec t)
 565         {
 566                 return t.IsStruct;
 567         }
 568
 569         public static bool IsFamilyAccessible (TypeSpec type, TypeSpec parent)
 570         {
 571 //              TypeParameter tparam = LookupTypeParameter (type);
 572 //              TypeParameter pparam = LookupTypeParameter (parent);
 573
 574                 if (type.Kind == MemberKind.TypeParameter && parent.Kind == MemberKind.TypeParameter) { // (tparam != null) && (pparam != null)) {
 575                         if (type == parent)
 576                                 return true;
 577
 578                         throw new NotImplementedException ("net");
 579 //                      return tparam.IsSubclassOf (parent);
 580                 }
 581
 582                 do {
 583                         if (IsInstantiationOfSameGenericType (type, parent))
 584                                 return true;
 585
 586                         type = type.BaseType;
 587                 } while (type != null);
 588
 589                 return false;
 590         }
 591
 592         //
 593         // Checks whether `type' is a subclass or nested child of `base_type'.
 594         //
 595         public static bool IsNestedFamilyAccessible (TypeSpec type, TypeSpec base_type)
 596         {
 597                 do {
 598                         if (IsFamilyAccessible (type, base_type))
 599                                 return true;
 600
 601                         // Handle nested types.
 602                         type = type.DeclaringType;
 603                 } while (type != null);
 604
 605                 return false;
 606         }
 607
 608         //
 609         // Checks whether `type' is a nested child of `parent'.
 610         //
 611         public static bool IsNestedChildOf (TypeSpec type, TypeSpec parent)
 612         {
 613                 if (type == null)
 614                         return false;
 615
 616                 type = type.GetDefinition (); // DropGenericTypeArguments (type);
 617                 parent = parent.GetDefinition (); // DropGenericTypeArguments (parent);
 618
 619                 if (type == parent)
 620                         return false;
 621
 622                 type = type.DeclaringType;
 623                 while (type != null) {
 624                         if (type.GetDefinition () == parent)
 625                                 return true;
 626
 627                         type = type.DeclaringType;
 628                 }
 629
 630                 return false;
 631         }
 632
 633         public static bool IsSpecialType (TypeSpec t)
 634         {
 635                 return t == arg_iterator_type || t == typed_reference_type;
 636         }
 637
 638         //
 639         // Checks whether `invocationAssembly' is same or a friend of the assembly
 640         //
 641         public static bool IsThisOrFriendAssembly (Assembly invocationAssembly, Assembly assembly)
 642         {
 643                 if (assembly == null)
 644                         throw new ArgumentNullException ("assembly");
 645
 646                 // TODO: This can happen for constants used at assembly level and
 647                 // predefined members
 648                 // But there is no way to test for it for now, so it could be abused
 649                 // elsewhere too.
 650                 if (invocationAssembly == null)
 651                         invocationAssembly = CodeGen.Assembly.Builder;
 652
 653                 if (invocationAssembly == assembly)
 654                         return true;
 655
 656                 bool value;
 657                 if (assembly_internals_vis_attrs.TryGetValue (assembly, out value))
 658                         return value;
 659
 660                 object[] attrs = assembly.GetCustomAttributes (typeof (InternalsVisibleToAttribute), false);
 661                 if (attrs.Length == 0) {
 662                         assembly_internals_vis_attrs.Add (assembly, false);
 663                         return false;
 664                 }
 665
 666                 bool is_friend = false;
 667
 668                 AssemblyName this_name = CodeGen.Assembly.Name;
 669                 if (this_name == null)
 670                         return false;
 671
 672                 byte [] this_token = this_name.GetPublicKeyToken ();
 673                 foreach (InternalsVisibleToAttribute attr in attrs) {
 674                         if (attr.AssemblyName == null || attr.AssemblyName.Length == 0)
 675                                 continue;
 676
 677                         AssemblyName aname = null;
 678                         try {
 679                                 aname = new AssemblyName (attr.AssemblyName);
 680                         } catch (FileLoadException) {
 681                         } catch (ArgumentException) {
 682                         }
 683
 684                         if (aname == null || aname.Name != this_name.Name)
 685                                 continue;
 686
 687                         byte [] key_token = aname.GetPublicKeyToken ();
 688                         if (key_token != null) {
 689                                 if (this_token.Length == 0) {
 690                                         // Same name, but assembly is not strongnamed
 691                                         Error_FriendAccessNameNotMatching (aname.FullName, RootContext.ToplevelTypes.Compiler.Report);
 692                                         break;
 693                                 }
 694
 695                                 if (!CompareKeyTokens (this_token, key_token))
 696                                         continue;
 697                         }
 698
 699                         is_friend = true;
 700                         break;
 701                 }
 702
 703                 assembly_internals_vis_attrs.Add (assembly, is_friend);
 704                 return is_friend;
 705         }
 706
 707         static bool CompareKeyTokens (byte [] token1, byte [] token2)
 708         {
 709                 for (int i = 0; i < token1.Length; i++)
 710                         if (token1 [i] != token2 [i])
 711                                 return false;
 712
 713                 return true;
 714         }
 715
 716         static void Error_FriendAccessNameNotMatching (string other_name, Report Report)
 717         {
 718                 Report.Error (281,
 719                         "Friend access was granted to `{0}', but the output assembly is named `{1}'. Try adding a reference to `{0}' or change the output assembly name to match it",
 720                         other_name, CodeGen.Assembly.Name.FullName);
 721         }
 722
 723         public static TypeSpec GetElementType (TypeSpec t)
 724         {
 725                 return ((ElementTypeSpec)t).Element;
 726         }
 727
 728         /// <summary>
 729         /// This method is not implemented by MS runtime for dynamic types
 730         /// </summary>
 731         public static bool HasElementType (TypeSpec t)
 732         {
 733                 return t is ElementTypeSpec;
 734         }
 735
 736         static NumberFormatInfo nf_provider = CultureInfo.CurrentCulture.NumberFormat;
 737
 738         // This is a custom version of Convert.ChangeType() which works
 739         // with the TypeBuilder defined types when compiling corlib.
 740         public static object ChangeType (object value, TypeSpec targetType, out bool error)
 741         {
 742                 IConvertible convert_value = value as IConvertible;
 743
 744                 if (convert_value == null){
 745                         error = true;
 746                         return null;
 747                 }
 748
 749                 //
 750                 // We cannot rely on build-in type conversions as they are
 751                 // more limited than what C# supports.
 752                 // See char -> float/decimal/double conversion
 753                 //
 754                 error = false;
 755                 try {
 756                         if (targetType == TypeManager.bool_type)
 757                                 return convert_value.ToBoolean (nf_provider);
 758                         if (targetType == TypeManager.byte_type)
 759                                 return convert_value.ToByte (nf_provider);
 760                         if (targetType == TypeManager.char_type)
 761                                 return convert_value.ToChar (nf_provider);
 762                         if (targetType == TypeManager.short_type)
 763                                 return convert_value.ToInt16 (nf_provider);
 764                         if (targetType == TypeManager.int32_type)
 765                                 return convert_value.ToInt32 (nf_provider);
 766                         if (targetType == TypeManager.int64_type)
 767                                 return convert_value.ToInt64 (nf_provider);
 768                         if (targetType == TypeManager.sbyte_type)
 769                                 return convert_value.ToSByte (nf_provider);
 770
 771                         if (targetType == TypeManager.decimal_type) {
 772                                 if (convert_value.GetType () == typeof (char))
 773                                         return (decimal) convert_value.ToInt32 (nf_provider);
 774                                 return convert_value.ToDecimal (nf_provider);
 775                         }
 776
 777                         if (targetType == TypeManager.double_type) {
 778                                 if (convert_value.GetType () == typeof (char))
 779                                         return (double) convert_value.ToInt32 (nf_provider);
 780                                 return convert_value.ToDouble (nf_provider);
 781                         }
 782
 783                         if (targetType == TypeManager.float_type) {
 784                                 if (convert_value.GetType () == typeof (char))
 785                                         return (float)convert_value.ToInt32 (nf_provider);
 786                                 return convert_value.ToSingle (nf_provider);
 787                         }
 788
 789                         if (targetType == TypeManager.string_type)
 790                                 return convert_value.ToString (nf_provider);
 791                         if (targetType == TypeManager.ushort_type)
 792                                 return convert_value.ToUInt16 (nf_provider);
 793                         if (targetType == TypeManager.uint32_type)
 794                                 return convert_value.ToUInt32 (nf_provider);
 795                         if (targetType == TypeManager.uint64_type)
 796                                 return convert_value.ToUInt64 (nf_provider);
 797                         if (targetType == TypeManager.object_type)
 798                                 return value;
 799
 800                         error = true;
 801                 } catch {
 802                         error = true;
 803                 }
 804                 return null;
 805         }
 806
 807         /// <summary>
 808         ///   Utility function that can be used to probe whether a type
 809         ///   is managed or not.
 810         /// </summary>
 811         public static bool VerifyUnmanaged (CompilerContext ctx, TypeSpec t, Location loc)
 812         {
 813                 while (t.IsPointer)
 814                         t = GetElementType (t);
 815
 816                 if (IsUnmanagedType (t))
 817                         return true;
 818
 819                 ctx.Report.SymbolRelatedToPreviousError (t);
 820                 ctx.Report.Error (208, loc,
 821                         "Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'",
 822                         CSharpName (t));
 823
 824                 return false;
 825         }
 826 #region Generics
 827         // This method always return false for non-generic compiler,
 828         // while Type.IsGenericParameter is returned if it is supported.
 829         public static bool IsGenericParameter (TypeSpec type)
 830         {
 831                 return type.IsGenericParameter;
 832         }
 833
 834         public static bool IsGenericType (TypeSpec type)
 835         {
 836                 return type.IsGeneric;
 837         }
 838
 839         // TODO: Implement correctly
 840         public static bool ContainsGenericParameters (TypeSpec type)
 841         {
 842                 return type.GetMetaInfo ().ContainsGenericParameters;
 843         }
 844
 845         public static TypeSpec[] GetTypeArguments (TypeSpec t)
 846         {
 847                 // TODO: return empty array !!
 848                 return t.TypeArguments;
 849         }
 850
 851         /// <summary>
 852         ///   Check whether `type' and `parent' are both instantiations of the same
 853         ///   generic type.  Note that we do not check the type parameters here.
 854         /// </summary>
 855         public static bool IsInstantiationOfSameGenericType (TypeSpec type, TypeSpec parent)
 856         {
 857                 return type == parent || type.MemberDefinition == parent.MemberDefinition;
 858         }
 859
 860         public static bool IsNullableType (TypeSpec t)
 861         {
 862                 return generic_nullable_type == t.GetDefinition ();
 863         }
 864 #endregion
 865 }
 866
 867 }