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) {
}
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)
}
}
- // TODO: import volatile
-
return new FieldSpec (declaringType, definition, ImportType (fi.FieldType), fi, mod);
}
{
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;
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);
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;
continue;
imported = Import.CreateField (fi, declaringType);
+ if (imported == null)
+ continue;
+
break;
case MemberTypes.NestedType:
Type t = (Type) member;
throw new NotImplementedException ();
}
}
-}
\ No newline at end of file
+}