using System.Reflection.Emit;
using System.Reflection;
-#if BOOTSTRAP_WITH_OLDLIB
+#if BOOTSTRAP_WITH_OLDLIB || NET_2_1
using XmlElement = System.Object;
#else
using System.Xml;
: this (left, name, false, args, loc)
{ }
- public MemberName (string alias, string name, Location loc)
- : this (new MemberName (alias, loc), name, true, loc)
+ public MemberName (string alias, string name, TypeArguments args, Location loc)
+ : this (new MemberName (alias, loc), name, true, args, loc)
{ }
public MemberName (MemberName left, MemberName right)
if (TypeArguments != null)
return new SimpleName (Basename, TypeArguments, Location);
- if (RootContext.Version == LanguageVersion.LINQ && Name == "var")
- return new VarExpr (Name, Location);
-
return new SimpleName (Name, Location);
}
if (is_double_colon) {
if (Left.Left != null)
throw new InternalErrorException ("The left side of a :: should be an identifier");
- return new QualifiedAliasMember (Left.Name, Name, Location);
+ return new QualifiedAliasMember (Left.Name, Basename, Location);
}
Expression lexpr = Left.GetTypeExpression ();
ClsCompliantAttributeTrue = 1 << 7, // Type has CLSCompliant (true)
Excluded_Undetected = 1 << 8, // Conditional attribute has not been detected yet
Excluded = 1 << 9, // Method is conditional
- TestMethodDuplication = 1 << 10, // Test for duplication must be performed
+ MethodOverloadsExist = 1 << 10, // Test for duplication must be performed
IsUsed = 1 << 11,
IsAssigned = 1 << 12, // Field is assigned
- HasExplicitLayout = 1 << 13
+ HasExplicitLayout = 1 << 13,
+ PartialDefinitionExists = 1 << 14 // Set when corresponding partial method definition exists
}
/// <summary>
return false;
}
} else {
- if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0) {
+ if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.PARTIAL)) == 0) {
if (RootContext.Version >= LanguageVersion.LINQ && this is Property.PropertyMethod) {
Report.Error (840, Location, "`{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors",
GetSignatureForError ());
} else {
- Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract or extern",
+ Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract, extern, or partial",
GetSignatureForError ());
}
return false;
/// <summary>
/// Returns true when a member supports multiple overloads (methods, indexers, etc)
/// </summary>
- public virtual bool IsOverloadable {
- get {
- return false;
- }
- }
-
- public virtual void EnableOverloadChecks (MemberCore overload)
+ public virtual bool EnableOverloadChecks (MemberCore overload)
{
- caching_flags |= Flags.TestMethodDuplication;
+ return false;
}
/// <summary>
return true;
}
- if (symbol.IsOverloadable && mc.IsOverloadable) {
- symbol.EnableOverloadChecks (mc);
+ if (symbol.EnableOverloadChecks (mc))
return true;
- }
Report.SymbolRelatedToPreviousError (mc);
if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (symbol is ClassOrStruct || symbol is Interface)) {
throw new NotImplementedException (result.ToString ());
}
}
+
+ public bool CheckExistingMembersOverloads (MemberCore member, string name, Parameters parameters)
+ {
+ ArrayList entries = (ArrayList)member_hash [name];
+ if (entries == null)
+ return true;
+
+ int method_param_count = parameters.Count;
+ for (int i = entries.Count - 1; i >= 0; --i) {
+ CacheEntry ce = (CacheEntry) entries [i];
+
+ if (ce.Container != member.Parent.PartialContainer)
+ return true;
+
+ Type [] p_types;
+ ParameterData pd = null;
+ if ((ce.EntryType & EntryType.Property) != 0) {
+ p_types = TypeManager.GetArgumentTypes ((PropertyInfo) ce.Member);
+ } else {
+ MethodBase mb = (MethodBase) ce.Member;
+#if GMCS_SOURCE
+ // TODO: This is more like a hack, because we are adding generic methods
+ // twice with and without arity name
+ if (mb.IsGenericMethod && !member.MemberName.IsGeneric)
+ continue;
+#endif
+ pd = TypeManager.GetParameterData (mb);
+ p_types = pd.Types;
+ }
+
+ if (p_types.Length != method_param_count)
+ continue;
+
+ if (method_param_count > 0) {
+ int ii = method_param_count - 1;
+ Type type_a, type_b;
+ do {
+ type_a = parameters.ParameterType (ii);
+ type_b = p_types [ii];
+#if GMCS_SOURCE
+ if (type_a.IsGenericParameter && type_a.DeclaringMethod != null)
+ type_a = null;
+
+ if (type_b.IsGenericParameter && type_b.DeclaringMethod != null)
+ type_b = null;
+#endif
+ } while (type_a == type_b && ii-- != 0);
+
+ if (ii >= 0)
+ continue;
+
+ //
+ // Operators can differ in return type only
+ //
+ if (member is Operator) {
+ Operator op = TypeManager.GetMethod ((MethodBase) ce.Member) as Operator;
+ if (op != null && op.ReturnType != ((Operator) member).ReturnType)
+ continue;
+ }
+
+ //
+ // Report difference in parameter modifiers only
+ //
+ if (pd != null && !(member is AbstractPropertyEventMethod)) {
+ ii = method_param_count;
+ while (ii-- != 0 && parameters.ParameterModifier (ii) == pd.ParameterModifier (ii) &&
+ parameters.ExtensionMethodType == pd.ExtensionMethodType);
+
+ if (ii >= 0) {
+ MethodCore mc = TypeManager.GetMethod ((MethodBase) ce.Member) as MethodCore;
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ if ((member.ModFlags & Modifiers.PARTIAL) != 0 && (mc.ModFlags & Modifiers.PARTIAL) != 0) {
+ if (parameters.HasParams || pd.HasParams) {
+ Report.Error (758, member.Location,
+ "A partial method declaration and partial method implementation cannot differ on use of `params' modifier");
+ } else {
+ Report.Error (755, member.Location,
+ "A partial method declaration and partial method implementation must be both an extension method or neither");
+ }
+ } else {
+ Report.Error (663, member.Location,
+ "An overloaded method `{0}' cannot differ on use of parameter modifiers only",
+ member.GetSignatureForError ());
+ }
+ return false;
+ }
+ }
+ }
+
+ if ((ce.EntryType & EntryType.Method) != 0) {
+ Method method_a = member as Method;
+ Method method_b = TypeManager.GetMethod ((MethodBase) ce.Member) as Method;
+ if (method_a != null && method_b != null && (method_a.ModFlags & method_b.ModFlags & Modifiers.PARTIAL) != 0) {
+ const int partial_modifiers = Modifiers.STATIC | Modifiers.UNSAFE;
+ if (method_a.IsPartialDefinition == method_b.IsPartialImplementation) {
+ if ((method_a.ModFlags & partial_modifiers) == (method_b.ModFlags & partial_modifiers) ||
+ method_a.Parent.IsInUnsafeScope && method_b.Parent.IsInUnsafeScope) {
+ if (method_a.IsPartialImplementation) {
+ method_a.SetPartialDefinition (method_b);
+ entries.RemoveAt (i);
+ } else {
+ method_b.SetPartialDefinition (method_a);
+ }
+ continue;
+ }
+
+ if ((method_a.ModFlags & Modifiers.STATIC) != (method_b.ModFlags & Modifiers.STATIC)) {
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ Report.Error (763, member.Location,
+ "A partial method declaration and partial method implementation must be both `static' or neither");
+ }
+
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ Report.Error (764, member.Location,
+ "A partial method declaration and partial method implementation must be both `unsafe' or neither");
+ return false;
+ }
+
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ if (method_a.IsPartialDefinition) {
+ Report.Error (756, member.Location, "A partial method `{0}' declaration is already defined",
+ member.GetSignatureForError ());
+ }
+
+ Report.Error (757, member.Location, "A partial method `{0}' implementation is already defined",
+ member.GetSignatureForError ());
+ return false;
+ }
+
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ IMethodData duplicate_member = TypeManager.GetMethod ((MethodBase) ce.Member);
+ if (member is Operator && duplicate_member is Operator) {
+ Report.Error (557, member.Location, "Duplicate user-defined conversion in type `{0}'",
+ member.Parent.GetSignatureForError ());
+ return false;
+ }
+
+ bool is_reserved_a = member is AbstractPropertyEventMethod || member is Operator;
+ bool is_reserved_b = duplicate_member is AbstractPropertyEventMethod || duplicate_member is Operator;
+
+ if (is_reserved_a || is_reserved_b) {
+ Report.Error (82, member.Location, "A member `{0}' is already reserved",
+ is_reserved_a ?
+ TypeManager.GetFullNameSignature (ce.Member) :
+ member.GetSignatureForError ());
+ return false;
+ }
+ } else {
+ Report.SymbolRelatedToPreviousError (ce.Member);
+ }
+
+ Report.Error (111, member.Location,
+ "A member `{0}' is already defined. Rename this member or use different parameter types",
+ member.GetSignatureForError ());
+ return false;
+ }
+
+ return true;
+ }
}
}
projects / mono.git / blobdiff