2010-05-20 Marek Safar <marek.safar@gmail.com>

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

diff --git a/mcs/mcs/import.cs b/mcs/mcs/import.cs
index 2a02515b3ac3a89abeadcfd3adcc22cee4e1b612..8a960c3a5e3735fc9b7f84c379e9e969d1cc646b 100644 (file)
--- a/mcs/mcs/import.cs
+++ b/mcs/mcs/import.cs
@@ -89,6 +89,10 @@ namespace Mono.CSharp
                                        break;
                        }
 
+                       // Ignore private fields (even for error reporting) to not require extra dependencies
+                       if (mod == Modifiers.PRIVATE)
+                               return null;
+
                        var definition = new ImportedMemberDefinition (fi);
 
                        if ((fa & FieldAttributes.Literal) != 0) {
@@ -104,6 +108,16 @@ namespace Mono.CSharp
                                }
 
                                mod |= Modifiers.READONLY;
+                       } else {
+                               var reqs = fi.GetRequiredCustomModifiers ();
+                               if (reqs.Length > 0) {
+                                       foreach (Type t in reqs) {
+                                               if (t == typeof (System.Runtime.CompilerServices.IsVolatile)) {
+                                                       mod |= Modifiers.VOLATILE;
+                                                       break;
+                                               }
+                                       }
+                               }
                        }
 
                        if ((fa & FieldAttributes.Static) != 0)
@@ -116,8 +130,6 @@ namespace Mono.CSharp
                                }
                        }
 
-                       // TODO: import volatile
-
                        return new FieldSpec (declaringType, definition, ImportType (fi.FieldType), fi, mod);
                }
 
@@ -177,7 +189,20 @@ namespace Mono.CSharp
                {
                        var tspec = new T [tparams.Length - first];
                        for (int pos = first; pos < tparams.Length; ++pos) {
-                               tspec [pos - first] = (T) CreateType (tparams [pos]);
+                               var type = tparams[pos];
+                               if (type.HasElementType) {
+                                       var element = type.GetElementType ();
+                                       var spec = CreateType (element);
+
+                                       if (type.IsArray) {
+                                               tspec[pos - first] = (T) (TypeSpec) ArrayContainer.MakeType (spec, type.GetArrayRank ());
+                                               continue;
+                                       }
+
+                                       throw new NotImplementedException ("Unknown element type " + type.ToString ());
+                               }
+
+                               tspec [pos - first] = (T) CreateType (type);
                        }
 
                        return tspec;
@@ -445,14 +470,19 @@ namespace Mono.CSharp
                        PredefinedTypeSpec pt;
 
                        if (kind == MemberKind.Enum) {
-                               const BindingFlags any_member = BindingFlags.DeclaredOnly |
-                                       BindingFlags.Static | BindingFlags.Instance |
+                               const BindingFlags underlying_member = BindingFlags.DeclaredOnly |
+                                       BindingFlags.Instance |
                                        BindingFlags.Public | BindingFlags.NonPublic;
 
-                               var u_type = type.GetField (Enum.UnderlyingValueField, any_member);
-                               if (u_type != null) {
-                                       spec = new EnumSpec (declaringType, definition, Import.CreateType (u_type.FieldType), type, mod);
+                               var type_members = type.GetFields (underlying_member);
+                               foreach (var type_member in type_members) {
+                                       spec = new EnumSpec (declaringType, definition, Import.CreateType (type_member.FieldType), type, mod);
+                                       break;
                                }
+
+                               if (spec == null)
+                                       kind = MemberKind.Class;
+
                        } else if (kind == MemberKind.TypeParameter) {
                                // Return as type_cache was updated
                                return CreateTypeParameter (type, declaringType);
@@ -961,18 +991,12 @@ namespace Mono.CSharp
                                                continue;
 
                                        imported = Import.CreateMethod (mb, declaringType);
-                                       var name = imported.Name;
-                                       if (imported.Kind == MemberKind.Method && name.Length > 4) {
-                                               if ((name[3] == '_' && (name.StartsWith ("get", StringComparison.Ordinal) ||
-                                                        name.StartsWith ("set", StringComparison.Ordinal) || 
-                                                        name.StartsWith ("add", StringComparison.Ordinal))) ||
-                                                       name.Length > 7 && name[6] == '_' && name.StartsWith ("remove", StringComparison.Ordinal)) {
+                                       if (imported.Kind == MemberKind.Method) {
+                                               if (possible_accessors == null)
+                                                       possible_accessors = new Dictionary<MethodBase, MethodSpec> (ReferenceEquality<MethodBase>.Default);
 
-                                                       if (possible_accessors == null)
-                                                               possible_accessors = new Dictionary<MethodBase, MethodSpec> ();
-
-                                                       possible_accessors.Add (mb, (MethodSpec) imported);
-                                               }
+                                               // There are no metadata rules for accessors, we have to any method as possible candidate
+                                               possible_accessors.Add (mb, (MethodSpec) imported);
                                        }
 
                                        break;
@@ -1041,6 +1065,9 @@ namespace Mono.CSharp
                                                continue;
 
                                        imported = Import.CreateField (fi, declaringType);
+                                       if (imported == null)
+                                               continue;
+
                                        break;
                                case MemberTypes.NestedType:
                                        Type t = (Type) member;
@@ -1117,4 +1144,4 @@ namespace Mono.CSharp
                        throw new NotImplementedException ();
                }
        }
-}
\ No newline at end of file
+}