//
// Returns true when object at local position has dynamic attribute flag
//
- public bool IsDynamicObject (MetadataImporter importer)
+ public bool IsDynamicObject ()
{
if (provider != null)
- ReadAttribute (importer);
+ ReadAttribute ();
return flags != null && Position < flags.Length && flags[Position];
}
//
// Returns true when DynamicAttribute exists
//
- public bool HasDynamicAttribute (MetadataImporter importer)
+ public bool HasDynamicAttribute ()
{
if (provider != null)
- ReadAttribute (importer);
+ ReadAttribute ();
return flags != null;
}
- void ReadAttribute (MetadataImporter importer)
+ void ReadAttribute ()
{
IList<CustomAttributeData> cad;
if (provider is MemberInfo) {
public FieldSpec CreateField (FieldInfo fi, TypeSpec declaringType)
{
- Modifiers mod = 0;
+ Modifiers mod;
var fa = fi.Attributes;
switch (fa & FieldAttributes.FieldAccessMask) {
case FieldAttributes.Public:
// IFoo<A<T>> foo; // A<T> is definition in this case
// }
//
- // TODO: Is full logic from CreateType needed here as well?
- //
if (!IsMissingType (type) && type.IsGenericTypeDefinition) {
- var targs = CreateGenericArguments (0, type.GetGenericArguments (), dtype);
+ var start_pos = spec.DeclaringType == null ? 0 : spec.DeclaringType.MemberDefinition.TypeParametersCount;
+ var targs = CreateGenericArguments (start_pos, type.GetGenericArguments (), dtype);
spec = spec.MakeGenericType (module, targs);
}
}
TypeSpec spec;
if (import_cache.TryGetValue (type, out spec)) {
if (spec.BuiltinType == BuiltinTypeSpec.Type.Object) {
- if (dtype.IsDynamicObject (this))
+ if (dtype.IsDynamicObject ())
return module.Compiler.BuiltinTypes.Dynamic;
return spec;
if (!spec.IsGeneric || type.IsGenericTypeDefinition)
return spec;
- if (!dtype.HasDynamicAttribute (this))
+ if (!dtype.HasDynamicAttribute ())
return spec;
// We've found same object in the cache but this one has a dynamic custom attribute
if (kind == MemberKind.Class) {
if ((ma & TypeAttributes.Sealed) != 0) {
- mod |= Modifiers.SEALED;
if ((ma & TypeAttributes.Abstract) != 0)
mod |= Modifiers.STATIC;
+ else
+ mod |= Modifiers.SEALED;
} else if ((ma & TypeAttributes.Abstract) != 0) {
mod |= Modifiers.ABSTRACT;
}
protected AttributesBag cattrs;
protected readonly MetadataImporter importer;
- public ImportedDefinition (MemberInfo provider, MetadataImporter importer)
+ protected ImportedDefinition (MemberInfo provider, MetadataImporter importer)
{
this.provider = provider;
this.importer = importer;
}
}
+ bool ITypeDefinition.IsCyclicTypeForwarder {
+ get {
+#if STATIC
+ return ((MetaType) provider).__IsCyclicTypeForwarder;
+#else
+ return false;
+#endif
+ }
+ }
+
public override string Name {
get {
if (name == null) {
}
- public static void Error_MissingDependency (IMemberContext ctx, List<TypeSpec> types, Location loc)
+ public static void Error_MissingDependency (IMemberContext ctx, List<MissingTypeSpecReference> missing, Location loc)
{
//
// Report details about missing type and most likely cause of the problem.
var report = ctx.Module.Compiler.Report;
- for (int i = 0; i < types.Count; ++i) {
- var t = types [i];
+ for (int i = 0; i < missing.Count; ++i) {
+ var t = missing [i].Type;
//
// Report missing types only once
string name = t.GetSignatureForError ();
- if (t.MemberDefinition.DeclaringAssembly == ctx.Module.DeclaringAssembly) {
+ var caller = missing[i].Caller;
+ if (caller.Kind != MemberKind.MissingType)
+ report.SymbolRelatedToPreviousError (caller);
+
+ var definition = t.MemberDefinition;
+ if (definition.DeclaringAssembly == ctx.Module.DeclaringAssembly) {
report.Error (1683, loc,
"Reference to type `{0}' claims it is defined in this assembly, but it is not defined in source or any added modules",
name);
- } else if (t.MemberDefinition.DeclaringAssembly.IsMissing) {
- if (t.MemberDefinition.IsTypeForwarder) {
+ } else if (definition.DeclaringAssembly.IsMissing) {
+ if (definition.IsTypeForwarder) {
report.Error (1070, loc,
"The type `{0}' has been forwarded to an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
- name, t.MemberDefinition.DeclaringAssembly.FullName);
+ name, definition.DeclaringAssembly.FullName);
} else {
report.Error (12, loc,
"The type `{0}' is defined in an assembly that is not referenced. Consider adding a reference to assembly `{1}'",
- name, t.MemberDefinition.DeclaringAssembly.FullName);
+ name, definition.DeclaringAssembly.FullName);
}
+ } else if (definition.IsTypeForwarder) {
+ report.Error (731, loc, "The type forwarder for type `{0}' in assembly `{1}' has circular dependency",
+ name, definition.DeclaringAssembly.FullName);
} else {
report.Error (1684, loc,
"Reference to type `{0}' claims it is defined assembly `{1}', but it could not be found",
if (get == null && set == null)
continue;
- imported = importer.CreateProperty (p, declaringType, get, set);
+ try {
+ imported = importer.CreateProperty (p, declaringType, get, set);
+ } catch (Exception ex) {
+ throw new InternalErrorException (ex, "Could not import property `{0}' inside `{1}'",
+ p.Name, declaringType.GetSignatureForError ());
+ }
+
if (imported == null)
continue;
}
}
+ bool ITypeDefinition.IsCyclicTypeForwarder {
+ get {
+ return false;
+ }
+ }
+
public string Namespace {
get {
return null;
projects / mono.git / blobdiff