/// <summary> /// This function computes the Base class and also the /// list of interfaces that the class or struct @c implements. /// /// The return value is an array (might be null) of /// interfaces implemented (as Types). /// /// The @base_class argument is set to the base object or null /// if this is `System.Object'. /// </summary> protected virtual TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { base_class = null; if (type_bases == null) return null; int count = type_bases.Count; TypeExpr [] ifaces = null; var base_context = new BaseContext (this); for (int i = 0, j = 0; i < count; i++){ FullNamedExpression fne = type_bases [i]; TypeExpr fne_resolved = fne.ResolveAsTypeTerminal (base_context, false); if (fne_resolved == null) continue; if (i == 0 && Kind == MemberKind.Class && !fne_resolved.Type.IsInterface) { if (fne_resolved.Type == InternalType.Dynamic) { Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type", GetSignatureForError ()); continue; } base_type = fne_resolved.Type; base_class = fne_resolved; continue; } if (ifaces == null) ifaces = new TypeExpr [count - i]; if (fne_resolved.Type.IsInterface) { for (int ii = 0; ii < j; ++ii) { if (fne_resolved.Type == ifaces [ii].Type) { Report.Error (528, Location, "`{0}' is already listed in interface list", fne_resolved.GetSignatureForError ()); break; } } if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved.Type)) { Report.Error (61, fne.Location, "Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'", fne_resolved.GetSignatureForError (), GetSignatureForError ()); } } else { Report.SymbolRelatedToPreviousError (fne_resolved.Type); if (Kind != MemberKind.Class) { Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ()); } else if (base_class != null) Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')", GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ()); else { Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first", GetSignatureForError (), fne_resolved.GetSignatureForError ()); } } ifaces [j++] = fne_resolved; } return ifaces; }
protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class); if (base_class == null) { if (spec != TypeManager.object_type) base_type = TypeManager.object_type; } else { if (base_type.IsGenericParameter){ Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (IsGeneric && base_type.IsAttribute) { Report.Error (698, base_class.Location, "A generic type cannot derive from `{0}' because it is an attribute class", base_class.GetSignatureForError ()); } else if (base_type.IsStatic) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (base_type.IsSealed) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (PartialContainer.IsStatic && base_class.Type != TypeManager.object_type) { Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object", GetSignatureForError (), base_class.GetSignatureForError ()); } if (base_type is BuildinTypeSpec && !(spec is BuildinTypeSpec) && (base_type == TypeManager.enum_type || base_type == TypeManager.value_type || base_type == TypeManager.multicast_delegate_type || base_type == TypeManager.delegate_type || base_type == TypeManager.array_type)) { Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); base_type = TypeManager.object_type; } if (!IsAccessibleAs (base_type)) { Report.SymbolRelatedToPreviousError (base_type); Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'", base_type.GetSignatureForError (), GetSignatureForError ()); } } if (PartialContainer.IsStatic && ifaces != null) { foreach (TypeExpr t in ifaces) Report.SymbolRelatedToPreviousError (t.Type); Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ()); } return ifaces; }
/// <summary> /// This function computes the Base class and also the /// list of interfaces that the class or struct @c implements. /// /// The return value is an array (might be null) of /// interfaces implemented (as Types). /// /// The @base_class argument is set to the base object or null /// if this is `System.Object'. /// </summary> protected virtual TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { base_class = null; if (type_bases == null) return null; int count = type_bases.Count; TypeExpr [] ifaces = null; IMemberContext base_context = new BaseContext (this); for (int i = 0, j = 0; i < count; i++){ FullNamedExpression fne = (FullNamedExpression) type_bases [i]; // // Standard ResolveAsTypeTerminal cannot be used in this case because // it does ObsoleteAttribute and constraint checks which require // base type to be set // TypeExpr fne_resolved = fne.ResolveAsBaseTerminal (base_context, false); if (fne_resolved == null) continue; if (i == 0 && Kind == Kind.Class && !fne_resolved.Type.IsInterface) { if (fne_resolved is DynamicTypeExpr) Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type", GetSignatureForError ()); else base_class = fne_resolved; continue; } if (ifaces == null) ifaces = new TypeExpr [count - i]; if (fne_resolved.Type.IsInterface) { for (int ii = 0; ii < j; ++ii) { if (TypeManager.IsEqual (fne_resolved.Type, ifaces [ii].Type)) { Report.Error (528, Location, "`{0}' is already listed in interface list", fne_resolved.GetSignatureForError ()); break; } } if (Kind == Kind.Interface && !IsAccessibleAs (fne_resolved.Type)) { Report.Error (61, fne.Location, "Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'", fne_resolved.GetSignatureForError (), GetSignatureForError ()); } } else { Report.SymbolRelatedToPreviousError (fne_resolved.Type); if (Kind != Kind.Class) { Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ()); } else if (base_class != null) Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')", GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ()); else { Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first", GetSignatureForError (), fne_resolved.GetSignatureForError ()); } } ifaces [j++] = fne_resolved; } return ifaces; }
protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class); if (base_class == null) { if (spec.BuiltinType != BuiltinTypeSpec.Type.Object) base_type = Compiler.BuiltinTypes.Object; } else { if (base_type.IsGenericParameter){ Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (IsGeneric && base_type.IsAttribute) { Report.Error (698, base_class.Location, "A generic type cannot derive from `{0}' because it is an attribute class", base_class.GetSignatureForError ()); } else if (base_type.IsStatic) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (base_type.IsSealed) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); } else if (PartialContainer.IsStatic && base_class.Type.BuiltinType != BuiltinTypeSpec.Type.Object) { Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object", GetSignatureForError (), base_class.GetSignatureForError ()); } switch (base_type.BuiltinType) { case BuiltinTypeSpec.Type.Enum: case BuiltinTypeSpec.Type.ValueType: case BuiltinTypeSpec.Type.MulticastDelegate: case BuiltinTypeSpec.Type.Delegate: case BuiltinTypeSpec.Type.Array: if (!(spec is BuiltinTypeSpec)) { Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'", GetSignatureForError (), base_type.GetSignatureForError ()); base_type = Compiler.BuiltinTypes.Object; } break; } if (!IsAccessibleAs (base_type)) { Report.SymbolRelatedToPreviousError (base_type); Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'", base_type.GetSignatureForError (), GetSignatureForError ()); } } if (PartialContainer.IsStatic && ifaces != null) { foreach (TypeExpr t in ifaces) Report.SymbolRelatedToPreviousError (t.Type); Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ()); } return ifaces; }
protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class) { TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class); if (base_class == null) { if (RootContext.StdLib) base_class = TypeManager.system_object_expr; else if (Name != "System.Object") base_class = TypeManager.system_object_expr; } else { if (Kind == Kind.Class && TypeManager.IsGenericParameter (base_class.Type)){ Report.Error ( 689, base_class.Location, "Cannot derive from `{0}' because it is a type parameter", base_class.GetSignatureForError ()); return ifaces; } if (IsGeneric && TypeManager.IsAttributeType (base_class.Type)) { Report.Error (698, base_class.Location, "A generic type cannot derive from `{0}' because it is an attribute class", base_class.GetSignatureForError ()); } if (base_class.IsSealed){ Report.SymbolRelatedToPreviousError (base_class.Type); if (base_class.Type.IsAbstract) { Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'", GetSignatureForError (), TypeManager.CSharpName (base_class.Type)); } else { Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'", GetSignatureForError (), TypeManager.CSharpName (base_class.Type)); } return ifaces; } if (!base_class.CanInheritFrom ()){ Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'", GetSignatureForError (), base_class.GetSignatureForError ()); return ifaces; } if (!IsAccessibleAs (base_class.Type)) { Report.SymbolRelatedToPreviousError (base_class.Type); Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'", TypeManager.CSharpName (base_class.Type), GetSignatureForError ()); } } if (PartialContainer.IsStaticClass) { if (base_class.Type != TypeManager.object_type) { Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object", GetSignatureForError (), base_class.GetSignatureForError ()); return ifaces; } if (ifaces != null) { foreach (TypeExpr t in ifaces) Report.SymbolRelatedToPreviousError (t.Type); Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ()); } } return ifaces; }