Add [Category ("NotWorking")] to failing test.

[mono.git] / mcs / mcs / assembly.cs

diff --git a/mcs/mcs/assembly.cs b/mcs/mcs/assembly.cs
index fa0a61b1750a0f24b4fe91c9926baaf8d8e80b60..4bbb7f3231377eb9c76dfc15d732a0c1a8c00284 100644 (file)
--- a/mcs/mcs/assembly.cs
+++ b/mcs/mcs/assembly.cs
@@ -7,7 +7,7 @@
 //
 // Copyright 2001, 2002, 2003 Ximian, Inc.
 // Copyright 2004-2011 Novell, Inc.
-// Copyright 2011 Xamarin Inc
+// Copyright 2011-2013 Xamarin Inc
 //
 
 
@@ -74,6 +74,9 @@ namespace Mono.CSharp
                Dictionary<ITypeDefinition, Attribute> emitted_forwarders;
                AssemblyAttributesPlaceholder module_target_attrs;
 
+               // Win32 version info values
+               string vi_product, vi_product_version, vi_company, vi_copyright, vi_trademark;
+
                protected AssemblyDefinition (ModuleContainer module, string name)
                {
                        this.module = module;
@@ -288,7 +291,7 @@ namespace Mono.CSharp
                                } else if (emitted_forwarders.ContainsKey (t.MemberDefinition)) {
                                        Report.SymbolRelatedToPreviousError (emitted_forwarders[t.MemberDefinition].Location, null);
                                        Report.Error (739, a.Location, "A duplicate type forward of type `{0}'",
-                                               TypeManager.CSharpName (t));
+                                               t.GetSignatureForError ());
                                        return;
                                }
 
@@ -297,13 +300,13 @@ namespace Mono.CSharp
                                if (t.MemberDefinition.DeclaringAssembly == this) {
                                        Report.SymbolRelatedToPreviousError (t);
                                        Report.Error (729, a.Location, "Cannot forward type `{0}' because it is defined in this assembly",
-                                               TypeManager.CSharpName (t));
+                                               t.GetSignatureForError ());
                                        return;
                                }
 
                                if (t.IsNested) {
                                        Report.Error (730, a.Location, "Cannot forward type `{0}' because it is a nested type",
-                                               TypeManager.CSharpName (t));
+                                               t.GetSignatureForError ());
                                        return;
                                }
 
@@ -347,15 +350,24 @@ namespace Mono.CSharp
                        } else if (a.Type == pa.RuntimeCompatibility) {
                                wrap_non_exception_throws_custom = true;
                        } else if (a.Type == pa.AssemblyFileVersion) {
-                               string value = a.GetString ();
-                               if (string.IsNullOrEmpty (value) || IsValidAssemblyVersion (value, false) == null) {
+                               vi_product_version = a.GetString ();
+                               if (string.IsNullOrEmpty (vi_product_version) || IsValidAssemblyVersion (vi_product_version, false) == null) {
                                        Report.Warning (1607, 1, a.Location, "The version number `{0}' specified for `{1}' is invalid",
-                                               value, a.Name);
+                                               vi_product_version, a.Name);
                                        return;
                                }
+                       } else if (a.Type == pa.AssemblyProduct) {
+                               vi_product = a.GetString ();
+                       } else if (a.Type == pa.AssemblyCompany) {
+                               vi_company = a.GetString ();
+                       } else if (a.Type == pa.AssemblyDescription) {
+                               // TODO: Needs extra api
+                       } else if (a.Type == pa.AssemblyCopyright) {
+                               vi_copyright = a.GetString ();
+                       } else if (a.Type == pa.AssemblyTrademark) {
+                               vi_trademark = a.GetString ();
                        }
 
-
                        SetCustomAttribute (ctor, cdata);
                }
 
@@ -370,7 +382,7 @@ namespace Mono.CSharp
                        // no working SRE API
                        foreach (var entry in Importer.Assemblies) {
                                var a = entry as ImportedAssemblyDefinition;
-                               if (a == null)
+                               if (a == null || a.IsMissing)
                                        continue;
 
                                if (public_key != null && !a.HasStrongName) {
@@ -749,7 +761,7 @@ namespace Mono.CSharp
                        if (Compiler.Settings.Win32ResourceFile != null) {
                                Builder.DefineUnmanagedResource (Compiler.Settings.Win32ResourceFile);
                        } else {
-                               Builder.DefineVersionInfoResource ();
+                               Builder.DefineVersionInfoResource (vi_product, vi_product_version, vi_company, vi_copyright, vi_trademark);
                        }
 
                        if (Compiler.Settings.Win32IconFile != null) {
@@ -907,7 +919,7 @@ namespace Mono.CSharp
                                                return;
                                        }
 
-                                       var mtype = texpr.Type.MemberDefinition as ClassOrStruct;
+                                       var mtype = texpr.MemberDefinition as ClassOrStruct;
                                        if (mtype == null) {
                                                Report.Error (1556, "`{0}' specified for Main method must be a valid class or struct", main_class);
                                                return;
@@ -1098,13 +1110,13 @@ namespace Mono.CSharp
                }
        }
 
-       abstract class AssemblyReferencesLoader<T>
+       abstract class AssemblyReferencesLoader<T> where T : class
        {
                protected readonly CompilerContext compiler;
 
                protected readonly List<string> paths;
 
-               public AssemblyReferencesLoader (CompilerContext compiler)
+               protected AssemblyReferencesLoader (CompilerContext compiler)
                {
                        this.compiler = compiler;
 
@@ -1167,15 +1179,27 @@ namespace Mono.CSharp
                                if (loaded.Contains (key))
                                        continue;
 
-                               // A corlib assembly is the first assembly which contains System.Object
-                               if (corlib_assembly == null && HasObjectType (a)) {
-                                       corlib_assembly = a;
-                                       continue;
-                               }
-
                                loaded.Add (key);
                        }
 
+                       if (corlib_assembly == null) {
+                               //
+                               // Requires second pass because HasObjectType can trigger assembly load event
+                               //
+                               for (int i = 0; i < loaded.Count; ++i) {
+                                       var assembly = loaded [i];
+
+                                       //
+                                       // corlib assembly is the first referenced assembly which contains System.Object
+                                       //
+                                       if (HasObjectType (assembly.Item2)) {
+                                               corlib_assembly = assembly.Item2;
+                                               loaded.RemoveAt (i);
+                                               break;
+                                       }
+                               }
+                       }
+
                        foreach (var entry in module.Compiler.Settings.AssemblyReferencesAliases) {
                                a = LoadAssemblyFile (entry.Item2, false);
                                if (a == null)