mcs/mcs/reflection.cs

   1 //
   2 // reflection.cs: System.Reflection and System.Reflection.Emit specific implementations
   3 //
   4 // Author: Marek Safar (marek.safar@gmail.com)
   5 //
   6 // Dual licensed under the terms of the MIT X11 or GNU GPL
   7 //
   8 // Copyright 2009-2010 Novell, Inc.
   9 //
  10 //
  11
  12 using System;
  13 using System.Collections.Generic;
  14 using System.Reflection;
  15 using System.IO;
  16 using System.Runtime.CompilerServices;
  17 using System.Reflection.Emit;
  18 using System.Security;
  19
  20 namespace Mono.CSharp
  21 {
  22 #if STATIC
  23         public class ReflectionImporter
  24         {
  25                 public ReflectionImporter (BuildinTypes buildin)
  26                 {
  27                         throw new NotSupportedException ();
  28                 }
  29
  30                 public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
  31                 {
  32                         throw new NotSupportedException ();
  33                 }
  34
  35                 public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
  36                 {
  37                         throw new NotSupportedException ();
  38                 }
  39
  40                 public TypeSpec ImportType (Type type)
  41                 {
  42                         throw new NotSupportedException ();
  43                 }
  44         }
  45 #else
  46         public sealed class ReflectionImporter : MetadataImporter
  47         {
  48                 public ReflectionImporter (BuildinTypes buildin)
  49                 {
  50                         Initialize (buildin);
  51                 }
  52
  53                 public override void AddCompiledType (TypeBuilder builder, TypeSpec spec)
  54                 {
  55                 }
  56
  57                 protected override MemberKind DetermineKindFromBaseType (Type baseType)
  58                 {
  59                         if (baseType == typeof (ValueType))
  60                                 return MemberKind.Struct;
  61
  62                         if (baseType == typeof (System.Enum))
  63                                 return MemberKind.Enum;
  64
  65                         if (baseType == typeof (MulticastDelegate))
  66                                 return MemberKind.Delegate;
  67
  68                         return MemberKind.Class;
  69                 }
  70
  71                 public override void GetCustomAttributeTypeName (CustomAttributeData cad, out string typeNamespace, out string typeName)
  72                 {
  73                         var dt = cad.Constructor.DeclaringType;
  74                         typeNamespace = dt.Namespace;
  75                         typeName = dt.Name;
  76                 }
  77
  78                 protected override bool HasVolatileModifier (Type[] modifiers)
  79                 {
  80                         foreach (var t in modifiers) {
  81                                 if (t == typeof (IsVolatile))
  82                                         return true;
  83                         }
  84
  85                         return false;
  86                 }
  87
  88                 public void ImportAssembly (Assembly assembly, RootNamespace targetNamespace)
  89                 {
  90                         // It can be used more than once when importing same assembly
  91                         // into 2 or more global aliases
  92                         var definition = GetAssemblyDefinition (assembly);
  93
  94                         //
  95                         // This part tries to simulate loading of top-level
  96                         // types only, any missing dependencies are ignores here.
  97                         // Full error report is reported later when the type is
  98                         // actually used
  99                         //
 100                         Type[] all_types;
 101                         try {
 102                                 all_types = assembly.GetTypes ();
 103                         } catch (ReflectionTypeLoadException e) {
 104                                 all_types = e.Types;
 105                         }
 106
 107                         ImportTypes (all_types, targetNamespace, definition.HasExtensionMethod);
 108                 }
 109
 110                 public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
 111                 {
 112                         var module_definition = new ImportedModuleDefinition (module, this);
 113                         module_definition.ReadAttributes ();
 114
 115                         Type[] all_types;
 116                         try {
 117                                 all_types = module.GetTypes ();
 118                         } catch (ReflectionTypeLoadException e) {
 119                                 all_types = e.Types;
 120                         }
 121
 122                         ImportTypes (all_types, targetNamespace, false);
 123
 124                         return module_definition;
 125                 }
 126
 127                 void Initialize (BuildinTypes buildin)
 128                 {
 129                         //
 130                         // Setup mapping for build-in types to avoid duplication of their definition
 131                         //
 132                         compiled_types.Add (typeof (object), buildin.Object);
 133                         compiled_types.Add (typeof (System.ValueType), buildin.ValueType);
 134                         compiled_types.Add (typeof (System.Attribute), buildin.Attribute);
 135
 136                         compiled_types.Add (typeof (int), buildin.Int);
 137                         compiled_types.Add (typeof (long), buildin.Long);
 138                         compiled_types.Add (typeof (uint), buildin.UInt);
 139                         compiled_types.Add (typeof (ulong), buildin.ULong);
 140                         compiled_types.Add (typeof (byte), buildin.Byte);
 141                         compiled_types.Add (typeof (sbyte), buildin.SByte);
 142                         compiled_types.Add (typeof (short), buildin.Short);
 143                         compiled_types.Add (typeof (ushort), buildin.UShort);
 144
 145                         compiled_types.Add (typeof (System.Collections.IEnumerator), buildin.IEnumerator);
 146                         compiled_types.Add (typeof (System.Collections.IEnumerable), buildin.IEnumerable);
 147                         compiled_types.Add (typeof (System.IDisposable), buildin.IDisposable);
 148
 149                         compiled_types.Add (typeof (char), buildin.Char);
 150                         compiled_types.Add (typeof (string), buildin.String);
 151                         compiled_types.Add (typeof (float), buildin.Float);
 152                         compiled_types.Add (typeof (double), buildin.Double);
 153                         compiled_types.Add (typeof (decimal), buildin.Decimal);
 154                         compiled_types.Add (typeof (bool), buildin.Bool);
 155                         compiled_types.Add (typeof (System.IntPtr), buildin.IntPtr);
 156                         compiled_types.Add (typeof (System.UIntPtr), buildin.UIntPtr);
 157
 158                         compiled_types.Add (typeof (System.MulticastDelegate), buildin.MulticastDelegate);
 159                         compiled_types.Add (typeof (System.Delegate), buildin.Delegate);
 160                         compiled_types.Add (typeof (System.Enum), buildin.Enum);
 161                         compiled_types.Add (typeof (System.Array), buildin.Array);
 162                         compiled_types.Add (typeof (void), buildin.Void);
 163                         compiled_types.Add (typeof (System.Type), buildin.Type);
 164                         compiled_types.Add (typeof (System.Exception), buildin.Exception);
 165                         compiled_types.Add (typeof (System.RuntimeFieldHandle), buildin.RuntimeFieldHandle);
 166                         compiled_types.Add (typeof (System.RuntimeTypeHandle), buildin.RuntimeTypeHandle);
 167                 }
 168         }
 169
 170         [System.Runtime.InteropServices.StructLayout (System.Runtime.InteropServices.LayoutKind.Explicit)]
 171         struct SingleConverter
 172         {
 173                 [System.Runtime.InteropServices.FieldOffset (0)]
 174                 int i;
 175                 [System.Runtime.InteropServices.FieldOffset (0)]
 176                 float f;
 177
 178                 public static int SingleToInt32Bits (float v)
 179                 {
 180                         SingleConverter c = new SingleConverter ();
 181                         c.f = v;
 182                         return c.i;
 183                 }
 184         }
 185
 186 #endif
 187
 188         public class AssemblyDefinitionDynamic : AssemblyDefinition
 189         {
 190                 //
 191                 // In-memory only assembly container
 192                 //
 193                 public AssemblyDefinitionDynamic (ModuleContainer module, string name)
 194                         : base (module, name)
 195                 {
 196                 }
 197
 198                 //
 199                 // Assembly container with file output
 200                 //
 201                 public AssemblyDefinitionDynamic (ModuleContainer module, string name, string fileName)
 202                         : base (module, name, fileName)
 203                 {
 204                 }
 205
 206                 public Module IncludeModule (string moduleFile)
 207                 {
 208                         return builder_extra.AddModule (moduleFile);
 209                 }
 210
 211 #if !STATIC
 212                 public override ModuleBuilder CreateModuleBuilder ()
 213                 {
 214                         if (file_name == null)
 215                                 return Builder.DefineDynamicModule (Name, false);
 216
 217                         return base.CreateModuleBuilder ();
 218                 }
 219 #endif
 220                 //
 221                 // Initializes the code generator
 222                 //
 223                 public bool Create (AppDomain domain, AssemblyBuilderAccess access)
 224                 {
 225 #if STATIC
 226                         throw new NotSupportedException ();
 227 #else
 228                         ResolveAssemblySecurityAttributes ();
 229                         var an = CreateAssemblyName ();
 230
 231                         try {
 232                                 Builder = file_name == null ?
 233                                         domain.DefineDynamicAssembly (an, access) :
 234                                         domain.DefineDynamicAssembly (an, access, Dirname (file_name));
 235                         } catch (ArgumentException) {
 236                                 // specified key may not be exportable outside it's container
 237                                 if (RootContext.StrongNameKeyContainer != null) {
 238                                         Report.Error (1548, "Could not access the key inside the container `" +
 239                                                 RootContext.StrongNameKeyContainer + "'.");
 240                                 }
 241                                 throw;
 242                         }
 243
 244                         module.Create (this, CreateModuleBuilder ());
 245                         builder_extra = new AssemblyBuilderMonoSpecific (Builder, Compiler);
 246                         return true;
 247 #endif
 248                 }
 249
 250                 static string Dirname (string name)
 251                 {
 252                         int pos = name.LastIndexOf ('/');
 253
 254                         if (pos != -1)
 255                                 return name.Substring (0, pos);
 256
 257                         pos = name.LastIndexOf ('\\');
 258                         if (pos != -1)
 259                                 return name.Substring (0, pos);
 260
 261                         return ".";
 262                 }
 263
 264 #if !STATIC
 265                 protected override void SaveModule (PortableExecutableKinds pekind, ImageFileMachine machine)
 266                 {
 267                         try {
 268                                 var module_only = typeof (AssemblyBuilder).GetProperty ("IsModuleOnly", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 269                                 var set_module_only = module_only.GetSetMethod (true);
 270
 271                                 set_module_only.Invoke (Builder, new object[] { true });
 272                         } catch {
 273                                 base.SaveModule (pekind, machine);
 274                         }
 275
 276                         Builder.Save (file_name, pekind, machine);
 277                 }
 278 #endif
 279         }
 280
 281         //
 282         // Extension to System.Reflection.Emit.AssemblyBuilder to have fully compatible
 283         // compiler
 284         //
 285         class AssemblyBuilderMonoSpecific : AssemblyBuilderExtension
 286         {
 287                 static MethodInfo adder_method;
 288                 static MethodInfo add_permission;
 289                 static MethodInfo add_type_forwarder;
 290                 static MethodInfo win32_icon_define;
 291                 static FieldInfo assembly_version;
 292                 static FieldInfo assembly_algorithm;
 293                 static FieldInfo assembly_culture;
 294                 static FieldInfo assembly_flags;
 295
 296                 AssemblyBuilder builder;
 297
 298                 public AssemblyBuilderMonoSpecific (AssemblyBuilder ab, CompilerContext ctx)
 299                         : base (ctx)
 300                 {
 301                         this.builder = ab;
 302                 }
 303
 304                 public override Module AddModule (string module)
 305                 {
 306                         try {
 307                                 if (adder_method == null)
 308                                         adder_method = typeof (AssemblyBuilder).GetMethod ("AddModule", BindingFlags.Instance | BindingFlags.NonPublic);
 309
 310                                 return (Module) adder_method.Invoke (builder, new object[] { module });
 311                         } catch {
 312                                 return base.AddModule (module);
 313                         }
 314                 }
 315
 316                 public override void AddPermissionRequests (PermissionSet[] permissions)
 317                 {
 318                         try {
 319                                 if (add_permission == null)
 320                                         add_permission = typeof (AssemblyBuilder).GetMethod ("AddPermissionRequests", BindingFlags.Instance | BindingFlags.NonPublic);
 321
 322                                 add_permission.Invoke (builder, permissions);
 323                         } catch {
 324                                 base.AddPermissionRequests (permissions);
 325                         }
 326                 }
 327
 328                 public override void AddTypeForwarder (TypeSpec type, Location loc)
 329                 {
 330                         try {
 331                                 if (add_type_forwarder == null) {
 332                                         add_type_forwarder = typeof (AssemblyBuilder).GetMethod ("AddTypeForwarder", BindingFlags.NonPublic | BindingFlags.Instance);
 333                                 }
 334
 335                                 add_type_forwarder.Invoke (builder, new object[] { type.GetMetaInfo () });
 336                         } catch {
 337                                 base.AddTypeForwarder (type, loc);
 338                         }
 339                 }
 340
 341                 public override void DefineWin32IconResource (string fileName)
 342                 {
 343                         try {
 344                                 if (win32_icon_define == null)
 345                                         win32_icon_define = typeof (AssemblyBuilder).GetMethod ("DefineIconResource", BindingFlags.Instance | BindingFlags.NonPublic);
 346
 347                                 win32_icon_define.Invoke (builder, new object[] { fileName });
 348                         } catch {
 349                                 base.DefineWin32IconResource (fileName);
 350                         }
 351                 }
 352
 353                 public override void SetAlgorithmId (uint value, Location loc)
 354                 {
 355                         try {
 356                                 if (assembly_algorithm == null)
 357                                         assembly_algorithm = typeof (AssemblyBuilder).GetField ("algid", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
 358
 359                                 assembly_algorithm.SetValue (builder, value);
 360                         } catch {
 361                                 base.SetAlgorithmId (value, loc);
 362                         }
 363                 }
 364
 365                 public override void SetCulture (string culture, Location loc)
 366                 {
 367                         try {
 368                                 if (assembly_culture == null)
 369                                         assembly_culture = typeof (AssemblyBuilder).GetField ("culture", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
 370
 371                                 assembly_culture.SetValue (builder, culture);
 372                         } catch {
 373                                 base.SetCulture (culture, loc);
 374                         }
 375                 }
 376
 377                 public override void SetFlags (uint flags, Location loc)
 378                 {
 379                         try {
 380                                 if (assembly_flags == null)
 381                                         assembly_flags = typeof (AssemblyBuilder).GetField ("flags", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
 382
 383                                 assembly_flags.SetValue (builder, flags);
 384                         } catch {
 385                                 base.SetFlags (flags, loc);
 386                         }
 387                 }
 388
 389                 public override void SetVersion (Version version, Location loc)
 390                 {
 391                         try {
 392                                 if (assembly_version == null)
 393                                         assembly_version = typeof (AssemblyBuilder).GetField ("version", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField);
 394
 395                                 assembly_version.SetValue (builder, version.ToString (4));
 396                         } catch {
 397                                 base.SetVersion (version, loc);
 398                         }
 399                 }
 400         }
 401
 402         //
 403         // Reflection based references loader
 404         //
 405         class DynamicLoader : AssemblyReferencesLoader<Assembly>
 406         {
 407                 readonly ReflectionImporter importer;
 408
 409                 public DynamicLoader (ReflectionImporter importer, CompilerContext compiler)
 410                         : base (compiler)
 411                 {
 412                         paths.Add (GetSystemDir ());
 413
 414                         this.importer = importer;
 415                 }
 416
 417                 public ReflectionImporter Importer {
 418                         get {
 419                                 return importer;
 420                         }
 421                 }
 422
 423                 protected override string[] GetDefaultReferences ()
 424                 {
 425                         //
 426                         // For now the "default config" is harcoded into the compiler
 427                         // we can move this outside later
 428                         //
 429                         var default_references = new List<string> (8);
 430
 431                         default_references.Add ("System");
 432                         default_references.Add ("System.Xml");
 433 #if NET_2_1
 434                         default_references.Add ("System.Net");
 435                         default_references.Add ("System.Windows");
 436                         default_references.Add ("System.Windows.Browser");
 437 #endif
 438
 439                         if (RootContext.Version > LanguageVersion.ISO_2)
 440                                 default_references.Add ("System.Core");
 441                         if (RootContext.Version > LanguageVersion.V_3)
 442                                 default_references.Add ("Microsoft.CSharp");
 443
 444                         return default_references.ToArray ();
 445                 }
 446
 447                 //
 448                 // Returns the directory where the system assemblies are installed
 449                 //
 450                 static string GetSystemDir ()
 451                 {
 452                         return Path.GetDirectoryName (typeof (object).Assembly.Location);
 453                 }
 454
 455                 public override bool HasObjectType (Assembly assembly)
 456                 {
 457                         return assembly.GetType (compiler.BuildinTypes.Object.FullName) != null;
 458                 }
 459
 460                 public override Assembly LoadAssemblyFile (string fileName)
 461                 {
 462                         return LoadAssemblyFile (fileName, false);
 463                 }
 464
 465                 Assembly LoadAssemblyFile (string assembly, bool soft)
 466                 {
 467                         Assembly a = null;
 468
 469                         try {
 470                                 try {
 471                                         char[] path_chars = { '/', '\\' };
 472
 473                                         if (assembly.IndexOfAny (path_chars) != -1) {
 474                                                 a = Assembly.LoadFrom (assembly);
 475                                         } else {
 476                                                 string ass = assembly;
 477                                                 if (ass.EndsWith (".dll") || ass.EndsWith (".exe"))
 478                                                         ass = assembly.Substring (0, assembly.Length - 4);
 479                                                 a = Assembly.Load (ass);
 480                                         }
 481                                 } catch (FileNotFoundException) {
 482                                         bool err = !soft;
 483                                         foreach (string dir in paths) {
 484                                                 string full_path = Path.Combine (dir, assembly);
 485                                                 if (!assembly.EndsWith (".dll") && !assembly.EndsWith (".exe"))
 486                                                         full_path += ".dll";
 487
 488                                                 try {
 489                                                         a = Assembly.LoadFrom (full_path);
 490                                                         err = false;
 491                                                         break;
 492                                                 } catch (FileNotFoundException) {
 493                                                 }
 494                                         }
 495
 496                                         if (err) {
 497                                                 Error_FileNotFound (assembly);
 498                                                 return a;
 499                                         }
 500                                 }
 501                         } catch (BadImageFormatException) {
 502                                 Error_FileCorrupted (assembly);
 503                         }
 504
 505                         return a;
 506                 }
 507
 508                 public override Assembly LoadAssemblyDefault (string fileName)
 509                 {
 510                         return LoadAssemblyFile (fileName, true);
 511                 }
 512
 513                 Module LoadModuleFile (AssemblyDefinitionDynamic assembly, string module)
 514                 {
 515                         string total_log = "";
 516
 517                         try {
 518                                 try {
 519                                         return assembly.IncludeModule (module);
 520                                 } catch (FileNotFoundException) {
 521                                         bool err = true;
 522                                         foreach (string dir in paths) {
 523                                                 string full_path = Path.Combine (dir, module);
 524                                                 if (!module.EndsWith (".netmodule"))
 525                                                         full_path += ".netmodule";
 526
 527                                                 try {
 528                                                         return assembly.IncludeModule (full_path);
 529                                                 } catch (FileNotFoundException ff) {
 530                                                         total_log += ff.FusionLog;
 531                                                 }
 532                                         }
 533                                         if (err) {
 534                                                 Error_FileNotFound (module);
 535                                                 return null;
 536                                         }
 537                                 }
 538                         } catch (BadImageFormatException) {
 539                                 Error_FileCorrupted (module);
 540                         }
 541
 542                         return null;
 543                 }
 544
 545                 public void LoadModules (AssemblyDefinitionDynamic assembly, RootNamespace targetNamespace)
 546                 {
 547                         if (RootContext.Modules.Count == 0)
 548                                 return;
 549
 550                         foreach (var moduleName in RootContext.Modules) {
 551                                 var m = LoadModuleFile (assembly, moduleName);
 552                                 if (m == null)
 553                                         continue;
 554
 555                                 var md = importer.ImportModule (m, targetNamespace);
 556                                 assembly.AddModule (md);
 557                         }
 558                 }
 559
 560                 public override void LoadReferences (ModuleContainer module)
 561                 {
 562                         Assembly corlib;
 563                         List<Tuple<RootNamespace, Assembly>> loaded;
 564                         base.LoadReferencesCore (module, out corlib, out loaded);
 565
 566                         if (corlib == null)
 567                                 return;
 568
 569                         importer.ImportAssembly (corlib, module.GlobalRootNamespace);
 570                         foreach (var entry in loaded) {
 571                                 importer.ImportAssembly (entry.Item2, entry.Item1);
 572                         }
 573                 }
 574         }
 575 }