static IEnumerable <MonoDevelop.Projects.Dom.IEvent> GetAllEvents(
MonoDevelop.Projects.Dom.Parser.ProjectDom projectDatabase,
MonoDevelop.Projects.Dom.IType cls)
{
foreach (MonoDevelop.Projects.Dom.IType type in projectDatabase.GetInheritanceTree(cls))
{
foreach (MonoDevelop.Projects.Dom.IEvent ev in type.Events)
{
yield return(ev);
}
}
}
static IEnumerable <MonoDevelop.Projects.Dom.IProperty> GetAllProperties(
MonoDevelop.Projects.Dom.Parser.ProjectDom projectDatabase,
MonoDevelop.Projects.Dom.IType cls)
{
foreach (MonoDevelop.Projects.Dom.IType type in projectDatabase.GetInheritanceTree(cls))
{
foreach (MonoDevelop.Projects.Dom.IProperty prop in type.Properties)
{
yield return(prop);
}
}
}
public override bool IsAccessibleFrom(MonoDevelop.Projects.Dom.Parser.ProjectDom dom, IType calledType, IMember member, bool includeProtected)
{
if (calledType != null)
{
foreach (IType baseType in dom.GetInheritanceTree(calledType))
{
if (baseType.FullName == calledType.FullName)
{
return(true);
}
}
}
return(base.IsAccessibleFrom(dom, calledType, member, includeProtected));
}
void UpdateTypeMembers (ProjectDom dom, NSObjectTypeInfo info, IType type)
{
info.Actions.Clear ();
info.Outlets.Clear ();
foreach (var prop in type.Properties) {
foreach (var att in prop.Attributes) {
bool isIBOutlet = att.AttributeType.FullName == iboutletAttType.FullName;
if (!isIBOutlet) {
if (att.AttributeType.FullName != connectAttType.FullName)
continue;
}
string name = null;
if (att.PositionalArguments.Count == 1)
name = (string)((System.CodeDom.CodePrimitiveExpression)att.PositionalArguments[0]).Value;
if (string.IsNullOrEmpty (name))
name = prop.Name;
// HACK: Work around bug #1586 in the least obtrusive way possible. Strip out any outlet
// with the name 'view' on subclasses of MonoTouch.UIKit.UIViewController to avoid
// conflicts with the view property mapped there
if (name == "view")
if (dom.GetInheritanceTree (type).Any (p => p.FullName == "MonoTouch.UIKit.UIViewController"))
continue;
var ol = new IBOutlet (name, prop.Name, null, prop.ReturnType.FullName);
if (MonoDevelop.DesignerSupport.CodeBehind.IsDesignerFile (prop.DeclaringType.CompilationUnit.FileName))
ol.IsDesigner = true;
info.Outlets.Add (ol);
break;
}
}
foreach (var meth in type.Methods) {
foreach (var att in meth.Attributes) {
bool isIBAction = att.AttributeType.FullName == ibactionAttType.FullName;
if (!isIBAction) {
if (att.AttributeType.FullName != exportAttType.FullName)
continue;
}
bool isDesigner = MonoDevelop.DesignerSupport.CodeBehind.IsDesignerFile (
meth.DeclaringType.CompilationUnit.FileName);
//only support Export from old designer files, user code must be IBAction
if (!isDesigner && !isIBAction)
continue;
string[] name = null;
if (att.PositionalArguments.Count == 1) {
var n = (string)((System.CodeDom.CodePrimitiveExpression)att.PositionalArguments[0]).Value;
if (!string.IsNullOrEmpty (n))
name = n.Split (colonChar);
}
var action = new IBAction (name != null? name [0] : meth.Name, meth.Name);
int i = 1;
foreach (var param in meth.Parameters) {
string label = name != null && i < name.Length? name[i] : null;
if (label != null && label.Length == 0)
label = null;
action.Parameters.Add (new IBActionParameter (label, param.Name, null, param.ReturnType.FullName));
}
if (MonoDevelop.DesignerSupport.CodeBehind.IsDesignerFile (meth.DeclaringType.CompilationUnit.FileName))
action.IsDesigner = true;
info.Actions.Add (action);
break;
}
}
}
public override INode Visit(IReturnType type, IType contextType)
{
if (type.GenericArguments.Count == 0 && unit != null)
{
foreach (IUsing u in unit.Usings)
{
if (u.IsFromNamespace || u.Aliases.Count == 0 && contextType != null && u.Region.Contains(contextType.Location))
{
continue;
}
foreach (KeyValuePair <string, IReturnType> alias in u.Aliases)
{
if (alias.Key == type.FullName)
{
return(Visit(alias.Value, contextType));
}
}
}
}
if (currentMethod != null)
{
IMethod method = null;
if (currentMethod.IsOverride)
{
foreach (IType curType2 in db.GetInheritanceTree(contextType))
{
foreach (IMethod curMethod in curType2.SearchMember(currentMethod.Name, true))
{
if (!curMethod.IsOverride && curMethod.Parameters.Count == currentMethod.Parameters.Count && curMethod.TypeParameters.Count == currentMethod.TypeParameters.Count)
{
method = curMethod;
break;
}
}
if (method != null)
{
break;
}
}
}
if (method == null)
{
method = currentMethod;
}
int idx = currentMethod.GetTypeParameterIndex(type.Name);
if (idx >= 0)
{
ITypeParameter t = method.TypeParameters [idx];
DomReturnType typeParameterReturnType = new DomReturnType(type.FullName);
DomType constructedType = new InstantiatedParameterType(db, method, t);
if (constructedType.BaseType == null)
{
constructedType.BaseType = DomReturnType.Object;
}
constructedType.SourceProjectDom = db;
typeParameterReturnType.Type = constructedType;
typeParameterReturnType.ArrayDimensions = type.ArrayDimensions;
typeParameterReturnType.PointerNestingLevel = type.PointerNestingLevel;
for (int i = 0; i < type.ArrayDimensions; i++)
{
typeParameterReturnType.SetDimension(i, type.GetDimension(i));
}
return(typeParameterReturnType);
}
}
IType lookupType = db.SearchType(unit, contextType, resolvePosition, type);
if (visitAttribute && lookupType == null && type.Parts.Count > 0)
{
string oldName = type.Parts [type.Parts.Count - 1].Name;
type.Parts [type.Parts.Count - 1].Name += "Attribute";
lookupType = db.SearchType(unit, contextType, resolvePosition, type);
if (lookupType == null)
{
type.Parts [type.Parts.Count - 1].Name = oldName;
}
}
if (lookupType == null)
{
unresolvedCount++;
return(type);
}
List <IReturnTypePart> parts = new List <IReturnTypePart> (type.Parts.Count);
IType curType = lookupType.DeclaringType;
int typePart = 0;
while (curType != null)
{
ReturnTypePart newPart = new ReturnTypePart {
Name = curType.Name
};
newPart.IsGenerated = true;
for (int n = curType.TypeParameters.Count - 1; n >= 0; n--)
{
newPart.AddTypeParameter(new DomReturnType("?"));
}
if (typePart >= type.Parts.Count || (type.Parts [typePart].Name != newPart.Name || type.Parts [typePart].GenericArguments.Count != newPart.GenericArguments.Count))
{
parts.Insert(0, newPart);
typePart++;
}
curType = curType.DeclaringType;
}
foreach (ReturnTypePart part in type.Parts)
{
ReturnTypePart newPart = new ReturnTypePart();
newPart.Name = part.Name;
foreach (IReturnType ga in part.GenericArguments)
{
newPart.AddTypeParameter((IReturnType)ga.AcceptVisitor(this, contextType));
}
parts.Add(newPart);
}
DomReturnType rt = new DomReturnType(lookupType.Namespace, parts);
// Make sure the whole type is resolved
if (parts.Count > 1 && db.SearchType(unit, contextType, resolvePosition, rt) == null)
{
unresolvedCount++;
return(type);
}
rt.PointerNestingLevel = type.PointerNestingLevel;
rt.IsNullable = type.IsNullable;
rt.ArrayDimensions = type.ArrayDimensions;
for (int n = 0; n < type.ArrayDimensions; n++)
{
rt.SetDimension(n, type.GetDimension(n));
}
return(db.GetSharedReturnType(rt));
}
internal static void AddType (ProjectDom dom, List<object> result, IType type, IMember callingMember, bool showStatic, Func<IMember, bool> filter)
{
// System.Console.WriteLine("Add Type:" + type);
if (type == null)
return;
if (showStatic && type.ClassType == ClassType.Enum) {
foreach (IMember member in type.Fields) {
result.Add (member);
}
return;
}
List<IType> accessibleStaticTypes = null;
if (callingMember != null && callingMember.DeclaringType != null)
accessibleStaticTypes = DomType.GetAccessibleExtensionTypes (dom, callingMember.DeclaringType.CompilationUnit);
/* TODO: Typed extension methods
IList<IReturnType> genericParameters = null;
if (type is InstantiatedType)
genericParameters = ((InstantiatedType)type).GenericParameters;*/
bool includeProtected = callingMember != null ? DomType.IncludeProtected (dom, type, callingMember.DeclaringType) : false;
if (accessibleStaticTypes != null) {
foreach (IMethod extensionMethod in type.GetAllExtensionMethods (accessibleStaticTypes))
result.Add (extensionMethod);
}
foreach (IType curType in dom.GetInheritanceTree (type)) {
if (curType.ClassType == ClassType.Interface && type.ClassType != ClassType.Interface && !(type is InstantiatedParameterType))
continue;
foreach (IMember member in curType.Members) {
if (callingMember != null && !member.IsAccessibleFrom (dom, type, callingMember, includeProtected))
continue;
// handled by member.IsAccessibleFrom
// if (member.IsProtected && !includeProtected)
// continue;
if (member is IMethod && (((IMethod)member).IsConstructor || ((IMethod)member).IsFinalizer))
continue;
if (!showStatic && member is IType)
continue;
if (filter != null && filter (member))
continue;
if (member is IType || !(showStatic ^ (member.IsStatic || member.IsConst))) {
result.Add (member);
}
}
// if (showStatic)
// break;
}
}
internal static IEnumerable<INode> CollectMembers (ProjectDom dom, IMember member)
{
if (member is IMethod && ((IMethod)member).IsConstructor) {
yield return member;
} else {
bool isOverrideable = member.DeclaringType.ClassType == ClassType.Interface || member.IsOverride || member.IsVirtual || member.IsAbstract;
bool isLastMember = false;
// for members we need to collect the whole 'class' of members (overloads & implementing types)
HashSet<string> alreadyVisitedTypes = new HashSet<string> ();
foreach (IType type in dom.GetInheritanceTree (member.DeclaringType)) {
if (type.ClassType == ClassType.Interface || isOverrideable || type.DecoratedFullName == member.DeclaringType.DecoratedFullName) {
// search in the class for the member
foreach (IMember interfaceMember in type.SearchMember (member.Name, true)) {
if (interfaceMember.MemberType == member.MemberType)
yield return interfaceMember;
}
// now search in all subclasses of this class for the member
isLastMember = !member.IsOverride;
foreach (IType implementingType in dom.GetSubclasses (type)) {
string name = implementingType.DecoratedFullName;
if (alreadyVisitedTypes.Contains (name))
continue;
alreadyVisitedTypes.Add (name);
foreach (IMember typeMember in implementingType.SearchMember (member.Name, true)) {
if (typeMember.MemberType == member.MemberType) {
isLastMember = type.ClassType != ClassType.Interface && (typeMember.IsVirtual || typeMember.IsAbstract || !typeMember.IsOverride);
yield return typeMember;
}
}
if (!isOverrideable)
break;
}
if (isLastMember)
break;
}
}
}
}
public static bool IdentifierExistsInClass (ProjectDom parserContext, IType cls, string identifier)
{
foreach (IMember member in cls.Members)
if (member.Name == identifier)
return true;
return VisibleIdentifierExistsInBaseClasses (parserContext.GetInheritanceTree (cls), identifier);
}
//TODO: check accessibility
public static IEnumerable<IMethod> GetCompatibleMethodsInClass (ProjectDom ctx, IType cls, IMethod matchMeth)
{
IList<IType>[] pars = new IList<IType>[matchMeth.Parameters.Count];
for (int i = 0; i < matchMeth.Parameters.Count; i++) {
IType t = ctx.GetType (matchMeth.Parameters[i].ReturnType);
if (t != null)
pars[i] = new List<IType> (ctx.GetInheritanceTree (t));
else
pars[i] = new IType[0];
}
foreach (IType type in ctx.GetInheritanceTree (cls)) {
if (type.ClassType != ClassType.Class)
continue;
foreach (IMethod method in type.Methods) {
if (method.IsPrivate || method.Parameters.Count != pars.Length || method.ReturnType.FullName != matchMeth.ReturnType.FullName
|| method.IsInternal)
continue;
bool allCompatible = true;
//compare each parameter
for (int i = 0; i < pars.Length; i++) {
bool parCompatible = false;
foreach (IType t in pars[i]) {
if (t.FullName == method.Parameters[i].ReturnType.FullName) {
parCompatible = true;
break;
}
}
if (!parCompatible) {
allCompatible = false;
break;
}
}
if (allCompatible)
yield return method;
}
}
}
void ResolveTypes (ProjectDom dom, NSObjectTypeInfo type)
{
NSObjectTypeInfo resolved;
if (type.BaseObjCType == null && type.BaseCliType != null) {
if (cliTypes.TryGetValue (type.BaseCliType, out resolved)) {
if (resolved.IsModel)
type.BaseIsModel = true;
type.BaseObjCType = resolved.ObjCName;
if (resolved.IsUserType)
type.UserTypeReferences.Add (resolved.ObjCName);
} else {
//managed classes many have implicitly registered base classes with a name not
//expressible in obj-c. In this case, the best we can do is walk down the
//hierarchy until we find a valid base class
foreach (var bt in dom.GetInheritanceTree (dom.GetType (type.BaseCliType))) {
if (cliTypes.TryGetValue (bt.FullName, out resolved)) {
if (resolved.IsModel)
type.BaseIsModel = true;
type.BaseObjCType = resolved.ObjCName;
if (resolved.IsUserType)
type.UserTypeReferences.Add (resolved.ObjCName);
break;
}
}
if (type.BaseObjCType == null)
Console.WriteLine ("Could not resolve CLI type '{0}'", type.BaseCliType);
}
}
if (type.BaseCliType == null && type.BaseObjCType != null) {
if (objcTypes.TryGetValue (type.BaseObjCType, out resolved))
type.BaseCliType = resolved.CliName;
}
foreach (var outlet in type.Outlets) {
if (outlet.ObjCType == null) {
if (cliTypes.TryGetValue (outlet.CliType, out resolved)) {
outlet.ObjCType = resolved.ObjCName;
if (resolved.IsUserType)
type.UserTypeReferences.Add (resolved.ObjCName);
}
}
if (outlet.CliType == null) {
if (objcTypes.TryGetValue (outlet.ObjCType, out resolved))
outlet.CliType = resolved.CliName;
}
}
foreach (var action in type.Actions) {
foreach (var param in action.Parameters) {
if (param.ObjCType == null) {
if (cliTypes.TryGetValue (param.CliType, out resolved)) {
param.ObjCType = resolved.ObjCName;
if (resolved.IsUserType)
type.UserTypeReferences.Add (resolved.ObjCName);
}
}
if (param.CliType == null) {
if (objcTypes.TryGetValue (param.ObjCType, out resolved))
param.CliType = resolved.CliName;
}
}
}
}
public override IEnumerable <IType> GetInheritanceTree(IType type)
{
return(decorated.GetInheritanceTree(type));
}
