protected void Error_CannotChangeAccessModifiers (MemberCore member, MemberSpec base_member) { var base_modifiers = base_member.Modifiers; // Remove internal modifier from types which are not internally accessible if ((base_modifiers & Modifiers.AccessibilityMask) == (Modifiers.PROTECTED | Modifiers.INTERNAL) && !base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (member.Module.DeclaringAssembly)) base_modifiers = Modifiers.PROTECTED; Report.SymbolRelatedToPreviousError (base_member); Report.Error (507, member.Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'", member.GetSignatureForError (), ModifiersExtensions.AccessibilityName (base_modifiers), base_member.GetSignatureForError ()); }
static public string CSharpSignature (MemberSpec mb) { return mb.GetSignatureForError (); }
// // Performs various checks on the MethodInfo `mb' regarding the modifier flags // that have been defined. // protected virtual bool CheckOverrideAgainstBase (MemberSpec base_member) { bool ok = true; if ((base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) == 0) { Report.SymbolRelatedToPreviousError (base_member); Report.Error (506, Location, "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override", GetSignatureForError (), TypeManager.CSharpSignature (base_member)); ok = false; } // Now we check that the overriden method is not final if ((base_member.Modifiers & Modifiers.SEALED) != 0) { Report.SymbolRelatedToPreviousError (base_member); Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed", GetSignatureForError (), TypeManager.CSharpSignature (base_member)); ok = false; } var base_member_type = ((IInterfaceMemberSpec) base_member).MemberType; if (!TypeSpecComparer.Override.IsEqual (MemberType, base_member_type)) { Report.SymbolRelatedToPreviousError (base_member); if (this is PropertyBasedMember) { Report.Error (1715, Location, "`{0}': type must be `{1}' to match overridden member `{2}'", GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ()); } else { Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'", GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ()); } ok = false; } return ok; }
bool OverloadResolver.IErrorHandler.AmbiguousCandidates (ResolveContext ec, MemberSpec best, MemberSpec ambiguous) { ec.Report.SymbolRelatedToPreviousError (best); ec.Report.Warning (278, 2, loc, "`{0}' contains ambiguous implementation of `{1}' pattern. Method `{2}' is ambiguous with method `{3}'", expr.Type.GetSignatureForError (), "enumerable", best.GetSignatureForError (), ambiguous.GetSignatureForError ()); ambiguous_getenumerator_name = true; return true; }
static public string GetFullNameSignature (MemberSpec mi) { return mi.GetSignatureForError (); }
static public string GetFullNameSignature(MemberSpec mi) { return(mi.GetSignatureForError()); }
static public string CSharpSignature(MemberSpec mb) { return(mb.GetSignatureForError()); }
protected void Error_CannotChangeAccessModifiers (MemberCore member, MemberSpec base_member) { Report.SymbolRelatedToPreviousError (base_member); Report.Error (507, member.Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'", member.GetSignatureForError (), ModifiersExtensions.AccessibilityName (base_member.Modifiers), base_member.GetSignatureForError ()); }
protected static void Error_CannotAccessProtected(ResolveContext ec, Location loc, MemberSpec m, TypeSpec qualifier, TypeSpec container) { ec.Report.Error (1540, loc, "Cannot access protected member `{0}' via a qualifier of type `{1}'." + " The qualifier must be of type `{2}' or derived from it", m.GetSignatureForError (), TypeManager.CSharpName (qualifier), TypeManager.CSharpName (container)); }
public void Error_TypeArgumentsCannotBeUsed(Report report, Location loc, MemberSpec member, int arity) { // Better message for possible generic expressions if (member != null && (member.Kind & MemberKind.GenericMask) != 0) { report.SymbolRelatedToPreviousError (member); if (member is TypeSpec) member = ((TypeSpec) member).GetDefinition (); else member = ((MethodSpec) member).GetGenericMethodDefinition (); string name = member.Kind == MemberKind.Method ? "method" : "type"; if (member.IsGeneric) { report.Error (305, loc, "Using the generic {0} `{1}' requires `{2}' type argument(s)", name, member.GetSignatureForError (), member.Arity.ToString ()); } else { report.Error (308, loc, "The non-generic {0} `{1}' cannot be used with the type arguments", name, member.GetSignatureForError ()); } } else { report.Error (307, loc, "The {0} `{1}' cannot be used with type arguments", ExprClassName, GetSignatureForError ()); } }
static void CheckConversion (IMemberContext mc, MemberSpec context, TypeSpec atype, TypeParameterSpec tparam, TypeSpec ttype, Location loc) { var expr = new EmptyExpression (atype); if (!Convert.ImplicitStandardConversionExists (expr, ttype)) { mc.Compiler.Report.SymbolRelatedToPreviousError (tparam); if (TypeManager.IsValueType (atype)) { mc.Compiler.Report.Error (315, loc, "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing conversion from `{0}' to `{3}'", atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ()); } else if (atype.IsGenericParameter) { mc.Compiler.Report.Error (314, loc, "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing or type parameter conversion from `{0}' to `{3}'", atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ()); } else { mc.Compiler.Report.Error (311, loc, "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no implicit reference conversion from `{0}' to `{3}'", atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ()); } } }
static bool CheckConstraint (IMemberContext mc, MemberSpec context, TypeSpec atype, TypeParameterSpec tparam, Location loc) { // // First, check the `class' and `struct' constraints. // if (tparam.HasSpecialClass && !TypeManager.IsReferenceType (atype)) { mc.Compiler.Report.Error (452, loc, "The type `{0}' must be a reference type in order to use it as type parameter `{1}' in the generic type or method `{2}'", TypeManager.CSharpName (atype), tparam.GetSignatureForError (), context.GetSignatureForError ()); return false; } if (tparam.HasSpecialStruct && (!TypeManager.IsValueType (atype) || TypeManager.IsNullableType (atype))) { mc.Compiler.Report.Error (453, loc, "The type `{0}' must be a non-nullable value type in order to use it as type parameter `{1}' in the generic type or method `{2}'", TypeManager.CSharpName (atype), tparam.GetSignatureForError (), context.GetSignatureForError ()); return false; } // // The class constraint comes next. // if (tparam.HasTypeConstraint) { CheckConversion (mc, context, atype, tparam, tparam.BaseType, loc); } // // Now, check the interfaces and type parameters constraints // if (tparam.Interfaces != null) { if (TypeManager.IsNullableType (atype)) { mc.Compiler.Report.Error (313, loc, "The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. The nullable type `{0}' never satisfies interface constraint", atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError ()); } else { foreach (TypeSpec iface in tparam.Interfaces) { CheckConversion (mc, context, atype, tparam, iface, loc); } } } // // Finally, check the constructor constraint. // if (!tparam.HasSpecialConstructor) return true; if (!HasDefaultConstructor (atype)) { mc.Compiler.Report.SymbolRelatedToPreviousError (atype); mc.Compiler.Report.Error (310, loc, "The type `{0}' must have a public parameterless constructor in order to use it as parameter `{1}' in the generic type or method `{2}'", TypeManager.CSharpName (atype), tparam.GetSignatureForError (), context.GetSignatureForError ()); return false; } return true; }