PointerType = 1 << 20,
InternalCompilerType = 1 << 21,
MissingType = 1 << 22,
+ Void = 1 << 23,
NestedMask = Class | Struct | Delegate | Enum | Interface,
GenericMask = Method | Class | Struct | Delegate | Interface,
- MaskType = Constructor | Event | Field | Method | Property | Indexer | Operator | Destructor | NestedMask,
- All = MaskType
+ MaskType = Constructor | Event | Field | Method | Property | Indexer | Operator | Destructor | NestedMask
}
[Flags]
public readonly MemberKind Kind;
public readonly AParametersCollection Parameters;
public readonly TypeSpec MemberType;
-
- int arity; // -1 to ignore the check
+ public readonly int Arity; // -1 to ignore the check
private MemberFilter (string name, MemberKind kind)
{
Kind = kind;
Parameters = null;
MemberType = null;
- arity = -1;
+ Arity = -1;
}
public MemberFilter (MethodSpec m)
Kind = MemberKind.Method;
Parameters = m.Parameters;
MemberType = m.ReturnType;
- arity = m.Arity;
+ Arity = m.Arity;
}
public MemberFilter (string name, int arity, MemberKind kind, AParametersCollection param, TypeSpec type)
Kind = kind;
Parameters = param;
MemberType = type;
- this.arity = arity;
+ this.Arity = arity;
}
public static MemberFilter Constructor (AParametersCollection param)
return false;
// Check arity when not disabled
- if (arity >= 0 && arity != other.Arity)
+ if (Arity >= 0 && Arity != other.Arity)
return false;
if (Parameters != null) {
//
public class MemberCache
{
+ [Flags]
enum StateFlags
{
HasConversionOperator = 1 << 1,
readonly Dictionary<string, IList<MemberSpec>> member_hash;
Dictionary<string, MemberSpec[]> locase_members;
IList<MethodSpec> missing_abstract;
- StateFlags state;
+ StateFlags state; // TODO: Move to TypeSpec or ITypeDefinition
public static readonly string IndexerNameAlias = "<this>";
{
if (member.Kind == MemberKind.Operator) {
var dt = member.DeclaringType;
- if (dt == TypeManager.string_type || dt == TypeManager.delegate_type || dt == TypeManager.multicast_delegate_type) {
+ switch (dt.BuiltinType) {
+ case BuiltinTypeSpec.Type.String:
+ case BuiltinTypeSpec.Type.Delegate:
+ case BuiltinTypeSpec.Type.MulticastDelegate:
// Some core types have user operators but they cannot be used as normal
// user operators as they are predefined and therefore having different
// rules (e.g. binary operators) by not setting the flag we hide them for
// user conversions
// TODO: Should I do this for all core types ?
- } else if (name == Operator.GetMetadataName (Operator.OpType.Implicit) || name == Operator.GetMetadataName (Operator.OpType.Explicit)) {
- state |= StateFlags.HasConversionOperator;
- } else {
- state |= StateFlags.HasUserOperator;
+ break;
+ default:
+ if (name == Operator.GetMetadataName (Operator.OpType.Implicit) || name == Operator.GetMetadataName (Operator.OpType.Explicit)) {
+ state |= StateFlags.HasConversionOperator;
+ } else {
+ state |= StateFlags.HasUserOperator;
+ }
+
+ break;
}
}
//
// Looks for extension methods with defined name and extension type
//
- public List<MethodSpec> FindExtensionMethods (TypeContainer invocationType, TypeSpec extensionType, string name, int arity)
+ public List<MethodSpec> FindExtensionMethods (IMemberContext invocationContext, TypeSpec extensionType, string name, int arity)
{
IList<MemberSpec> entries;
if (!member_hash.TryGetValue (name, out entries))
if (!ms.IsExtensionMethod)
continue;
- if (!ms.IsAccessible (invocationType.CurrentType))
+ if (!ms.IsAccessible (invocationContext))
continue;
- if ((ms.DeclaringType.Modifiers & Modifiers.INTERNAL) != 0 && !ms.DeclaringType.MemberDefinition.IsInternalAsPublic (invocationType.DeclaringAssembly))
+ //
+ // Extension methods cannot be nested hence checking parent is enough
+ //
+ if ((ms.DeclaringType.Modifiers & Modifiers.INTERNAL) != 0 && !ms.DeclaringType.MemberDefinition.IsInternalAsPublic (invocationContext.Module.DeclaringAssembly))
continue;
if (candidates == null)
// Returns base members of @member member if no exact match is found @bestCandidate returns
// the best match
//
- public static MemberSpec FindBaseMember (MemberCore member, out MemberSpec bestCandidate)
+ public static MemberSpec FindBaseMember (MemberCore member, out MemberSpec bestCandidate, ref bool overrides)
{
bestCandidate = null;
var container = member.Parent.PartialContainer.Definition;
}
string name = GetLookupName (member);
- IList<MemberSpec> applicable;
var member_param = member is IParametersMember ? ((IParametersMember) member).Parameters : null;
var mkind = GetMemberCoreKind (member);
bool member_with_accessors = mkind == MemberKind.Indexer || mkind == MemberKind.Property;
+ IList<MemberSpec> applicable;
+ MemberSpec ambig_candidate = null;
+
do {
if (container.MemberCache.member_hash.TryGetValue (name, out applicable)) {
for (int i = 0; i < applicable.Count; ++i) {
}
//
- // Skip override members with accessors they may not fully implement the base member
+ // Skip override for member with accessors. It may not fully implement the base member
+ // but keep flag we found an implementation in case the base member is abstract
//
- if (member_with_accessors) {
- if ((entry.Modifiers & (Modifiers.OVERRIDE | Modifiers.SEALED)) == Modifiers.OVERRIDE) {
- //
- // Set candidate to member override to flag we found an implementation
- //
- bestCandidate = entry;
- continue;
- }
- } else {
+ if (member_with_accessors && ((entry.Modifiers & (Modifiers.OVERRIDE | Modifiers.SEALED)) == Modifiers.OVERRIDE)) {
+ //
+ // Set candidate to override implementation to flag we found an implementation
+ //
+ overrides = true;
+ continue;
+ }
+
+ //
+ // For members with parameters we can encounter an ambiguous candidates (they match exactly)
+ // because generic type parameters could be inflated into same types
+ //
+ if (ambig_candidate == null && (entry.Kind & mkind & (MemberKind.Method | MemberKind.Indexer)) != 0) {
bestCandidate = null;
+ ambig_candidate = entry;
+ continue;
}
+ bestCandidate = ambig_candidate;
return entry;
}
}
- if (container.IsInterface)
+ if (container.IsInterface || ambig_candidate != null)
break;
container = container.BaseType;
} while (container != null);
- return null;
+ return ambig_candidate;
}
//
throw new NotImplementedException (member.GetType ().ToString ());
}
- public static IList<MemberSpec> GetCompletitionMembers (TypeSpec container, string name)
+ public static IList<MemberSpec> GetCompletitionMembers (IMemberContext ctx, TypeSpec container, string name)
{
var matches = new List<MemberSpec> ();
foreach (var entry in container.MemberCache.member_hash) {
if ((name_entry.Kind & (MemberKind.Constructor | MemberKind.Destructor | MemberKind.Operator)) != 0)
continue;
- if (!name_entry.IsAccessible (InternalType.FakeInternalType))
+ if (!name_entry.IsAccessible (ctx))
continue;
if (name == null || name_entry.Name.StartsWith (name)) {
//
// Returns members of @iface only, base members are ignored
//
- public static IList<MethodSpec> GetInterfaceMethods (TypeSpec iface)
+ public static List<MethodSpec> GetInterfaceMethods (TypeSpec iface)
{
//
// MemberCache flatten interfaces, therefore in cases like this one
projects / mono.git / blobdiff