return name + "`" + args.Count;
}
-
- public static string MakeName (string name, int count)
- {
- return name + "`" + count;
- }
}
public class SimpleMemberName
/// </summary>
internal Flags caching_flags;
- public MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
+ protected MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
{
this.Parent = parent;
member_name = name;
if ((mod_flags & Modifiers.COMPILER_GENERATED) != 0)
return true;
- return Parent == null ? false : Parent.IsCompilerGenerated;
+ return Parent != null && Parent.IsCompilerGenerated;
}
}
// protected type then the type is accessible
//
while (mc.Parent != null && mc.Parent.PartialContainer != null) {
- if (mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent))
+ if (mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent)) {
same_access_restrictions = true;
+ break;
+ }
+
mc = mc.Parent;
}
}
same_access_restrictions = p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
else if (al == (Modifiers.PROTECTED | Modifiers.INTERNAL))
same_access_restrictions = mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent) && p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
- else
+ else if (al == Modifiers.PROTECTED)
goto case Modifiers.PROTECTED;
+ else if (al == Modifiers.PRIVATE) {
+ if (p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly)) {
+ same_access_restrictions = true;
+ } else {
+ goto case Modifiers.PROTECTED;
+ }
+ }
break;
// Does extension methods look up to find a method which matches name and extensionType.
// Search starts from this namespace and continues hierarchically up to top level.
//
- public ExtensionMethodCandidates LookupExtensionMethod (TypeSpec extensionType, string name, int arity)
+ public ExtensionMethodCandidates LookupExtensionMethod (string name, int arity)
{
var m = Parent;
do {
var ns = m as NamespaceContainer;
if (ns != null)
- return ns.LookupExtensionMethod (this, extensionType, name, arity, 0);
+ return ns.LookupExtensionMethod (this, name, arity, 0);
m = m.Parent;
} while (m != null);
if (GetAttributeObsolete () != null)
return true;
- return Parent == null ? false : Parent.IsObsolete;
+ return Parent != null && Parent.IsObsolete;
}
}
if ((ModFlags & Modifiers.UNSAFE) != 0)
return true;
- return Parent == null ? false : Parent.IsUnsafe;
+ return Parent != null && Parent.IsUnsafe;
}
}
// will contain types only but it can have numerous values for members
// like methods where both return type and all parameters are checked
//
- public List<TypeSpec> GetMissingDependencies ()
+ public List<MissingTypeSpecReference> GetMissingDependencies ()
+ {
+ return GetMissingDependencies (this);
+ }
+
+ public List<MissingTypeSpecReference> GetMissingDependencies (MemberSpec caller)
{
if ((state & (StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected)) == 0)
return null;
state &= ~StateFlags.MissingDependency_Undetected;
var imported = definition as ImportedDefinition;
- List<TypeSpec> missing;
+ List<MissingTypeSpecReference> missing;
if (imported != null) {
- missing = ResolveMissingDependencies ();
+ missing = ResolveMissingDependencies (caller);
} else if (this is ElementTypeSpec) {
- missing = ((ElementTypeSpec) this).Element.GetMissingDependencies ();
+ missing = ((ElementTypeSpec) this).Element.GetMissingDependencies (caller);
} else {
missing = null;
}
return missing;
}
- public abstract List<TypeSpec> ResolveMissingDependencies ();
+ public abstract List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller);
protected virtual bool IsNotCLSCompliant (out bool attrValue)
{
public virtual string GetSignatureForError ()
{
- var bf = MemberDefinition as Property.BackingField;
+ var bf = MemberDefinition as Property.BackingFieldDeclaration;
string name;
if (bf == null) {
name = Name;
var ctype = ctx.CurrentType;
if (ma == Modifiers.PRIVATE) {
- if (ctype == null)
+ if (ctype == null || parentType == null)
return false;
//
// It's only accessible to the current class or children
return (state & StateFlags.CLSCompliant) != 0;
}
- public bool IsConditionallyExcluded (IMemberContext ctx, Location loc)
+ public bool IsConditionallyExcluded (IMemberContext ctx)
{
if ((Kind & (MemberKind.Class | MemberKind.Method)) == 0)
return false;