public static NSObjectProjectInfo GetProjectInfo (ProjectDom dom)
{
NSObjectProjectInfo info;
lock (infos) {
if (infos.TryGetValue (dom, out info))
return info;
//only include DOMs that can resolve NSObject
var nso = dom.GetType (nsobjectType);
if (nso == null) {
infos[dom] = null;
return null;
}
info = new NSObjectProjectInfo (dom);
infos[dom] = info;
dom.Unloaded += HandleDomUnloaded;
dom.ReferencesUpdated += HandleDomReferencesUpdated;
}
return info;
}
void FindOverridables (ProjectDom pctx, IType motherClass, IType cls, List<IMember> classMembers, List<IMember> interfaceMembers, List<IType> visited, bool includeOverridenClassMembers, bool includeOverridenInterfaceMembers)
{
if (visited.Contains (cls))
return;
visited.Add (cls);
foreach (IReturnType rt in cls.BaseTypes)
{
IType baseCls = pctx.GetType (rt);
if (baseCls == null)
continue;
if (visited.Contains (baseCls))
continue;
bool isInterface = baseCls.ClassType == ClassType.Interface;
if (isInterface && interfaceMembers == null)
continue;
List<IMember> list = isInterface ? interfaceMembers : classMembers;
bool includeOverriden = isInterface ? includeOverridenInterfaceMembers : includeOverridenClassMembers;
foreach (IMethod m in baseCls.Methods) {
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
continue;
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenMethod (motherClass, m)))
list.Add (m);
}
foreach (IProperty m in baseCls.Properties) {
if (m.IsIndexer)
continue;
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
continue;
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenProperty (motherClass, m)))
list.Add (m);
}
foreach (IProperty m in baseCls.Properties) {
if (!m.IsIndexer)
continue;
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
continue;
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed && (includeOverriden || !IsOverridenIndexer (motherClass, m)))
list.Add (m);
}
foreach (IEvent m in baseCls.Events) {
if (m.IsInternal && motherClass.SourceProject != null && motherClass.SourceProject != m.DeclaringType.SourceProject)
continue;
if ((isInterface || m.IsVirtual || m.IsAbstract) && !m.IsSpecialName && !m.IsSealed)
list.Add (m);
}
FindOverridables (pctx, motherClass, baseCls, classMembers, isInterface ? interfaceMembers : null, visited,
includeOverridenClassMembers, includeOverridenInterfaceMembers);
}
}
public MonoDevelop.Projects.Dom.ResolveResult GetLanguageItem (ProjectDom dom, Mono.TextEditor.TextEditorData data, int offset)
{
if (offset < 0)
return null;
string fileName = data.Document.FileName;
IParser parser = ProjectDomService.GetParser (fileName, data.Document.MimeType);
if (parser == null)
return null;
MonoDevelop.Ide.Gui.Document doc = IdeApp.Workbench.ActiveDocument;
if (doc == null)
return null;
IResolver resolver = parser.CreateResolver (dom, doc, fileName);
IExpressionFinder expressionFinder = parser.CreateExpressionFinder (dom);
if (resolver == null || expressionFinder == null)
return null;
string txt = data.Document.Text;
int wordEnd = offset;
while (wordEnd < txt.Length && (Char.IsLetterOrDigit (txt[wordEnd]) || txt[wordEnd] == '_'))
wordEnd++;
while (wordEnd < txt.Length - 1 && Char.IsWhiteSpace (txt[wordEnd]))
wordEnd++;
if (wordEnd < txt.Length && txt[wordEnd] == '<') {
bool wasMethodCall = false;
int saveEnd = wordEnd;
int matchingBracket = data.Document.GetMatchingBracketOffset (wordEnd);
if (matchingBracket > 0)
wordEnd = matchingBracket;
while (wordEnd < txt.Length - 1 && Char.IsWhiteSpace (txt[wordEnd]))
wordEnd++;
if (txt[wordEnd] == '(') {
matchingBracket = data.Document.GetMatchingBracketOffset (wordEnd);
if (matchingBracket > 0) {
wordEnd = matchingBracket;
wasMethodCall = true;
}
}
if (!wasMethodCall)
wordEnd = saveEnd;
}
ExpressionResult expressionResult = expressionFinder.FindExpression (txt, wordEnd);
if (expressionResult == null)
return null;
ResolveResult resolveResult;
DocumentLocation loc = data.Document.OffsetToLocation (offset);
string savedExpression = null;
// special handling for 'var' "keyword"
if (expressionResult.ExpressionContext == ExpressionContext.IdentifierExpected && expressionResult.Expression != null && expressionResult.Expression.Trim () == "var") {
int endOffset = data.Document.LocationToOffset (expressionResult.Region.End.Line - 1, expressionResult.Region.End.Column - 1);
StringBuilder identifer = new StringBuilder ();
for (int i = endOffset; i >= 0 && i < data.Document.Length; i++) {
char ch = data.Document.GetCharAt (i);
if (Char.IsWhiteSpace (ch))
continue;
if (ch == '=')
break;
if (Char.IsLetterOrDigit (ch) || ch =='_') {
identifer.Append (ch);
continue;
}
identifer.Length = 0;
break;
}
if (identifer.Length > 0) {
expressionResult.Expression = identifer.ToString ();
resolveResult = resolver.Resolve (expressionResult, new DomLocation (loc.Line + 1, loc.Column + 1));
if (resolveResult != null) {
resolveResult = new MemberResolveResult (dom.GetType (resolveResult.ResolvedType));
return resolveResult;
}
}
}
if (expressionResult.ExpressionContext == ExpressionContext.Attribute) {
savedExpression = expressionResult.Expression;
expressionResult.Expression += "Attribute";
expressionResult.ExpressionContext = ExpressionContext.ObjectCreation;
}
resolveResult = resolver.Resolve (expressionResult, new DomLocation (loc.Line + 1, loc.Column + 1));
if (savedExpression != null && resolveResult == null) {
expressionResult.Expression = savedExpression;
resolveResult = resolver.Resolve (expressionResult, new DomLocation (loc.Line + 1, loc.Column + 1));
}
// Search for possible generic parameters.
// if (this.resolveResult == null || this.resolveResult.ResolvedType == null || String.IsNullOrEmpty (this.resolveResult.ResolvedType.Name)) {
if (!expressionResult.Region.IsEmpty) {
int j = data.Document.LocationToOffset (expressionResult.Region.End.Line - 1, expressionResult.Region.End.Column - 1);
int bracket = 0;
for (int i = j; i >= 0 && i < data.Document.Length; i++) {
char ch = data.Document.GetCharAt (i);
if (Char.IsWhiteSpace (ch))
continue;
if (ch == '<') {
bracket++;
} else if (ch == '>') {
bracket--;
if (bracket == 0) {
expressionResult.Expression += data.Document.GetTextBetween (j, i + 1);
expressionResult.ExpressionContext = ExpressionContext.ObjectCreation;
resolveResult = resolver.Resolve (expressionResult, new DomLocation (loc.Line + 1, loc.Column + 1));
break;
}
} else {
if (bracket == 0)
break;
}
}
}
// To resolve method overloads the full expression must be parsed.
// ex.: Overload (1)/ Overload("one") - parsing "Overload" gives just a MethodResolveResult
// and for constructor initializers it's tried too to to resolve constructor overloads.
if (resolveResult is ThisResolveResult ||
resolveResult is BaseResolveResult ||
resolveResult is MethodResolveResult && ((MethodResolveResult)resolveResult).Methods.Count > 1) {
// put the search offset at the end of the invocation to be able to find the full expression
// the resolver finds it itself if spaces are between the method name and the argument opening parentheses.
while (wordEnd < txt.Length - 1 && Char.IsWhiteSpace (txt[wordEnd]))
wordEnd++;
if (txt[wordEnd] == '(') {
int matchingBracket = data.Document.GetMatchingBracketOffset (wordEnd);
if (matchingBracket > 0)
wordEnd = matchingBracket;
}
//Console.WriteLine (expressionFinder.FindFullExpression (txt, wordEnd));
ResolveResult possibleResult = resolver.Resolve (expressionFinder.FindFullExpression (txt, wordEnd), new DomLocation (loc.Line + 1, loc.Column + 1)) ?? resolveResult;
//Console.WriteLine ("possi:" + resolver.Resolve (expressionFinder.FindFullExpression (txt, wordEnd), new DomLocation (loc.Line + 1, loc.Column + 1)));
if (possibleResult is MethodResolveResult)
resolveResult = possibleResult;
}
return resolveResult;
}
public static void GetItem (ProjectDom ctx, Document doc, ITextBuffer editor, out ResolveResult resolveResult, out INode item)
{
resolveResult = GetResolveResult (doc, editor);
if (resolveResult is AggregatedResolveResult)
resolveResult = ((AggregatedResolveResult)resolveResult).PrimaryResult;
item = null;
if (resolveResult is ParameterResolveResult) {
item = ((ParameterResolveResult)resolveResult).Parameter;
} else if (resolveResult is LocalVariableResolveResult) {
item = ((LocalVariableResolveResult)resolveResult).LocalVariable;
//s.Append (ambience.GetString (((LocalVariableResolveResult)result).ResolvedType, WindowConversionFlags));
} else if (resolveResult is MemberResolveResult) {
item = ((MemberResolveResult)resolveResult).ResolvedMember;
if (item == null && ((MemberResolveResult)resolveResult).ResolvedType != null) {
item = ctx.GetType (((MemberResolveResult)resolveResult).ResolvedType);
}
} else if (resolveResult is MethodResolveResult) {
item = ((MethodResolveResult)resolveResult).MostLikelyMethod;
if (item == null && ((MethodResolveResult)resolveResult).ResolvedType != null) {
item = ctx.GetType (((MethodResolveResult)resolveResult).ResolvedType);
}
} else if (resolveResult is BaseResolveResult) {
item = ctx.GetType (((BaseResolveResult)resolveResult).ResolvedType);
} else if (resolveResult is ThisResolveResult) {
item = ctx.GetType (((ThisResolveResult)resolveResult).ResolvedType);
}
}
public virtual void Deserialize(XElement xml, ProjectDom dom)
{
var typeName = xml.Attribute ("Name");
if (typeName == null) {
throw new DeserializationException (xml.Name + " element with no \"Name\" attribute");
}
var domType = dom.GetType (DeserializeTypeName(typeName.Value));
if (domType == null) {
// TODO: Handle orphaned figures here..
throw new NotImplementedException ();
} else {
Rebuild (domType);
var members = xml.Element ("Members");
if (members != null) {
foreach (var memberElem in members.Elements ()) {
var memberName = memberElem.Attribute ("Name");
if (memberName == null) {
throw new DeserializationException ("Member element with no name in " + domType.DecoratedFullName);
}
var member = domType.SearchMember (memberName.Value, true).SingleOrDefault ();
if (member != null) {
foreach (var c in Children) {
var memberFigure = c.Children
.OfType<MemberFigure> ()
.Where (f => f.Name == member.Name)
.SingleOrDefault ();
if (memberFigure != null) {
memberFigure.Visible = false;
}
}
}
}
var compartmentsElem = xml.Element ("Compartments");
if (compartmentsElem != null) {
foreach (var compartmentElem in compartmentsElem.Elements ("Compartment")) {
var name = compartmentElem.Attribute ("Name");
if (name == null)
continue;
var compartment = Children
.OfType<CompartmentFigure> ()
.Where (c => c.Name == name.Value)
.SingleOrDefault ();
if (compartment == null)
continue;
var compartmentCollapsed = compartmentElem.Attribute ("Collapsed");
compartment.Collapsed = compartmentCollapsed != null
&& Boolean.Parse (compartmentCollapsed.Value);
}
}
}
}
var collapsed = xml.Attribute ("Collapsed");
Collapsed = collapsed != null && Boolean.Parse (collapsed.Value);
var position = xml.Element ("Position");
this.DeserializePosition (position);
}
static bool IsValidClass (ProjectDom ctx, IType cls, Stetic.Component obj)
{
if (cls.BaseTypes != null) {
string typeName = obj.Type.ClassName;
foreach (IReturnType bt in cls.BaseTypes) {
System.Console.WriteLine("tn:" + typeName + " bt:" + bt.FullName);
if (bt.FullName == typeName)
return true;
IType baseCls = ctx.GetType (bt);
if (baseCls != null && IsValidClass (ctx, baseCls, obj))
return true;
}
}
return false;
}
internal static void AddType (ProjectDom dom, List<object> result, IReturnType returnType, IMember callingMember, bool showStatic)
{
if (returnType == null || returnType.FullName == "System.Void")
return;
if (returnType.ArrayDimensions > 0) {
DomReturnType elementType = new DomReturnType (returnType.FullName);
elementType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < elementType.ArrayDimensions; i++) {
elementType.SetDimension (i, returnType.ArrayDimensions - 1);
}
elementType.PointerNestingLevel = returnType.PointerNestingLevel;
AddType (dom, result, dom.GetArrayType (elementType), callingMember, showStatic);
return;
}
IType type = dom.GetType (returnType);
AddType (dom, result, type, callingMember, showStatic);
}
//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;
}
}
}
public static IMethod GetMethodSignature (ProjectDom context, IEvent ev)
{
if (ev.ReturnType == null)
return null;
IType cls = context.GetType (ev.ReturnType);
if (cls == null)
return null;
foreach (IMethod m in cls.Methods)
if (m.Name == "Invoke")
return m;
return null;
}
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;
}
}
}
}
static IType EnsureClassExists (ProjectDom ctx, string className, DomRegion location)
{
IType cls = ctx.GetType (className);
if (cls == null)
throw new TypeNotFoundException (className, location, null);
return cls;
}
public override IType GetType(IReturnType returnType)
{
return(decorated.GetType(returnType));
}
public static IType AssemblyTypeLookup (ProjectDom assemblyDatabase, string namespac, string tagName)
{
return (assemblyDatabase == null)
? null
: assemblyDatabase.GetType (namespac + "." + tagName, false, false);
}
public static IEnumerable<IType> ListControlClasses (IType baseType, ProjectDom database, string namespac)
{
if (database == null)
yield break;
//return classes if they derive from system.web.ui.control
foreach (IType type in database.GetSubclasses (baseType, false, new string [] {namespac}))
if (!type.IsAbstract && type.IsPublic)
yield return type;
if (!baseType.IsAbstract && baseType.IsPublic && baseType.Namespace == namespac) {
IType t = database.GetType (baseType.FullName);
if (t != null)
yield return baseType;
}
}
bool IsSubclass (ProjectDom ctx, IType baseClass, IType subclass)
{
foreach (IReturnType clsName in subclass.BaseTypes)
if (clsName.FullName == baseClass.FullName)
return true;
foreach (IReturnType clsName in subclass.BaseTypes) {
IType cls = ctx.GetType (clsName);
if (cls != null && IsSubclass (ctx, baseClass, cls))
return true;
}
return false;
}
public static IMember GetCompatibleMemberInClass (ProjectDom ctx, IType cls, CodeTypeMember member)
{
//check for identical property names
foreach (IProperty prop in cls.Properties) {
if (string.Compare (prop.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) {
EnsureClassExists (ctx, prop.ReturnType.FullName, GetValidRegion (prop));
CodeMemberProperty memProp = member as CodeMemberProperty;
if (memProp == null || !IsTypeCompatible (ctx, prop.ReturnType.FullName, memProp.Type.BaseType))
throw new MemberExistsException (cls.FullName, MemberType.Property, member, GetValidRegion (prop), cls.CompilationUnit.FileName);
return prop;
}
}
//check for identical method names
foreach (IMethod meth in cls.Methods) {
if (string.Compare (meth.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) {
EnsureClassExists (ctx, meth.ReturnType.FullName, GetValidRegion (meth));
CodeMemberMethod memMeth = member as CodeMemberMethod;
if (memMeth == null || !IsTypeCompatible (ctx, meth.ReturnType.FullName, memMeth.ReturnType.BaseType))
throw new MemberExistsException (cls.FullName, MemberType.Method, member, GetValidRegion (meth), cls.CompilationUnit.FileName);
return meth;
}
}
//check for identical event names
foreach (IEvent ev in cls.Events) {
if (string.Compare (ev.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) {
EnsureClassExists (ctx, ev.ReturnType.FullName, GetValidRegion (ev));
CodeMemberEvent memEv = member as CodeMemberEvent;
if (memEv == null || !IsTypeCompatible (ctx, ev.ReturnType.FullName, memEv.Type.BaseType))
throw new MemberExistsException (cls.FullName, MemberType.Event, member, GetValidRegion (ev), cls.CompilationUnit.FileName);
return ev;
}
}
//check for identical field names
foreach (IField field in cls.Fields) {
if (string.Compare (field.Name, member.Name, StringComparison.OrdinalIgnoreCase) == 0) {
EnsureClassExists (ctx, field.ReturnType.FullName, GetValidRegion (field));
CodeMemberField memField = member as CodeMemberField;
if (memField == null || !IsTypeCompatible (ctx, field.ReturnType.FullName, memField.Type.BaseType))
throw new MemberExistsException (cls.FullName, MemberType.Field, member, GetValidRegion (field), cls.CompilationUnit.FileName);
return field;
}
}
//walk down into base classes, if any
foreach (IReturnType baseType in cls.BaseTypes) {
IType c = ctx.GetType (baseType);
if (c == null)
throw new TypeNotFoundException (baseType.FullName, cls.BodyRegion, cls.CompilationUnit.FileName);
IMember mem = GetCompatibleMemberInClass (ctx, c, member);
if (mem != null)
return mem;
}
//return null if no match
return null;
}
/// <summary>Filters out members whose names conflict with existing accessible members</summary>
/// <param name="members">Full list of CodeBehind members</param>
/// <param name="cls">The class to which these members' partial class will be added.</param>
/// <param name="designerFile">Members in this file will be ignored.</param>
/// <param name="resolveDom">The ProjectDom to use for resolving base types.</param>
/// <param name="internalDom">The ProjectDom to use for checking whether members are accessible as internal.</param>
/// <returns>The filtered list of non-conflicting members.</returns>
// TODO: check compatibilty with existing members
public static IEnumerable<CodeBehindMember> GetDesignerMembers (
IEnumerable<CodeBehindMember> members, IType cls, string designerFile, ProjectDom resolveDom,
ProjectDom internalDom)
{
var existingMembers = new HashSet<string> ();
while (cls != null) {
foreach (var member in cls.Members) {
if (member.IsPrivate || (member.IsInternal && member.DeclaringType.SourceProjectDom != internalDom))
continue;
if (member.DeclaringType.CompilationUnit.FileName == designerFile)
continue;
existingMembers.Add (member.Name);
}
if (cls.BaseType == null)
break;
cls = resolveDom.GetType (cls.BaseType);
}
return members.Where (m => !existingMembers.Contains (m.Name));
}
internal bool IsValidClass (ProjectDom ctx, IType cls)
{
if (cls.BaseTypes != null) {
foreach (IReturnType bt in cls.BaseTypes) {
if (bt.FullName == rootWidget.Component.Type.ClassName)
return true;
IType baseCls = ctx.GetType (bt);
if (baseCls != null && IsValidClass (ctx, baseCls))
return true;
}
}
return false;
}
public override IEnumerable<object> CreateResolveResult (ProjectDom dom, IMember callingMember)
{
List<object> result = new List<object> ();
if (IsLoopVariable) {
if (ResolvedType.Name == "IEnumerable" && ResolvedType.GenericArguments != null && ResolvedType.GenericArguments.Count > 0) {
MemberResolveResult.AddType (dom, result, ResolvedType.GenericArguments [0], callingMember, StaticResolve);
} else if (ResolvedType.Name == "IEnumerable") {
MemberResolveResult.AddType (dom, result, DomReturnType.Object, callingMember, StaticResolve);
} else {
MemberResolveResult.AddType (dom, result, dom.GetType (ResolvedType), callingMember, StaticResolve);
}
} else {
MemberResolveResult.AddType (dom, result, ResolvedType, callingMember, StaticResolve);
}
return result;
}
internal static bool IsValidClass (ProjectDom ctx, IType cls)
{
if (cls.BaseTypes != null) {
foreach (IReturnType bt in cls.BaseTypes) {
if (bt.FullName == "Gtk.ActionGroup")
return true;
IType baseCls = ctx.GetType (bt);
if (baseCls != null && IsValidClass (ctx, baseCls))
return true;
}
}
return false;
}
public override IEnumerable<object> CreateResolveResult (ProjectDom dom, IMember callingMember)
{
List<object> result = new List<object> ();
if (ResolvedExpression != null && ResolvedExpression.ExpressionContext != null && ResolvedExpression.ExpressionContext.IsObjectCreation) {
AddType (dom, result, dom.GetType (ResolvedType), callingMember, true);
} else {
AddType (dom, result, ResolvedType, callingMember, StaticResolve);
}
return result;
}
public string CreateTooltip (ProjectDom dom, ICompilationUnit unit, MonoDevelop.Projects.Dom.ResolveResult result, string errorInformations, Ambience ambience, Gdk.ModifierType modifierState)
{
OutputSettings settings = new OutputSettings (OutputFlags.ClassBrowserEntries | OutputFlags.IncludeParameterName | OutputFlags.IncludeKeywords | OutputFlags.IncludeMarkup | OutputFlags.UseFullName);
if ((Gdk.ModifierType.ShiftMask & modifierState) == Gdk.ModifierType.ShiftMask) {
settings.EmitNameCallback = delegate(INode domVisitable, ref string outString) {
// crop used namespaces.
if (unit != null) {
int len = 0;
foreach (IUsing u in unit.Usings) {
foreach (string ns in u.Namespaces) {
if (outString.StartsWith (ns + ".")) {
len = Math.Max (len, ns.Length + 1);
}
}
}
string newName = outString.Substring (len);
int count = 0;
// check if there is a name clash.
if (dom.GetType (newName) != null)
count++;
foreach (IUsing u in unit.Usings) {
foreach (string ns in u.Namespaces) {
if (dom.GetType (ns + "." + newName) != null)
count++;
}
}
if (len > 0 && count == 1)
outString = newName;
}
};
}
// Approximate value for usual case
StringBuilder s = new StringBuilder (150);
string doc = null;
if (result != null) {
if (result is AggregatedResolveResult)
result = ((AggregatedResolveResult)result).PrimaryResult;
if (result is ParameterResolveResult) {
s.Append ("<small><i>");
s.Append (paramStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (((ParameterResolveResult)result).Parameter, settings));
} else if (result is LocalVariableResolveResult) {
s.Append ("<small><i>");
s.Append (localStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (((LocalVariableResolveResult)result).ResolvedType, settings));
s.Append (" ");
s.Append (((LocalVariableResolveResult)result).LocalVariable.Name);
} else if (result is UnresolvedMemberResolveResult) {
s.Append (String.Format (GettextCatalog.GetString ("Unresolved member '{0}'"), ((UnresolvedMemberResolveResult)result).MemberName));
} else if (result is MethodResolveResult) {
MethodResolveResult mrr = (MethodResolveResult)result;
s.Append("<small><i>");
s.Append(methodStr);
s.Append("</i></small>\n");
s.Append(ambience.GetString(mrr.MostLikelyMethod, settings));
if (mrr.Methods.Count > 1) {
int overloadCount = mrr.Methods.Count - 1;
s.Append(string.Format(GettextCatalog.GetPluralString(" (+{0} overload)", " (+{0} overloads)", overloadCount), overloadCount));
}
doc = AmbienceService.GetDocumentationSummary(((MethodResolveResult)result).MostLikelyMethod);
} else if (result is MemberResolveResult) {
IMember member = ((MemberResolveResult)result).ResolvedMember;
if (member == null) {
IReturnType returnType = ((MemberResolveResult)result).ResolvedType;
if (returnType != null) {
IType type = dom.GetType (returnType);
if (type != null) {
s.Append ("<small><i>");
s.Append (typeStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (type, settings));
doc = AmbienceService.GetDocumentationSummary (type);
}
}
} else {
if (member is IField) {
s.Append ("<small><i>");
s.Append (fieldStr);
s.Append ("</i></small>\n");
} else if (member is IProperty) {
s.Append ("<small><i>");
s.Append (propertyStr);
s.Append ("</i></small>\n");
}
s.Append (ambience.GetString (member, settings));
doc = AmbienceService.GetDocumentationSummary (member);
}
} else if (result is NamespaceResolveResult) {
s.Append ("<small><i>");
s.Append (namespaceStr);
s.Append ("</i></small>\n");
s.Append (ambience.GetString (new Namespace (((NamespaceResolveResult)result).Namespace), settings));
} else {
s.Append (ambience.GetString (result.ResolvedType, settings));
}
if (!string.IsNullOrEmpty (doc)) {
s.Append ("\n<small>");
s.Append (AmbienceService.GetDocumentationMarkup ( "<summary>" + doc + "</summary>"));
s.Append ("</small>");
}
}
if (!string.IsNullOrEmpty (errorInformations)) {
if (s.Length != 0)
s.Append ("\n\n");
s.Append ("<small>");
s.Append (errorInformations);
s.Append ("</small>");
}
return s.ToString ();
}
internal IEnumerable<NSObjectTypeInfo> GetRegisteredObjects (ProjectDom dom)
{
var nso = dom.GetType (nsobjectType);
if (nso == null)
throw new Exception ("Could not get NSObject from type database");
//FIXME: only emit this for the wrapper NS
yield return new NSObjectTypeInfo ("NSObject", nsobjectType.FullName, null, null, false, false, false);
foreach (var type in dom.GetSubclasses (nso, false)) {
var info = ConvertType (dom, type);
if (info != null)
yield return info;
}
}
IType GetFullClass (out ProjectDom ctx)
{
if (project == null || className == null) {
ctx = null;
return null;
}
ctx = MonoDevelop.Projects.Dom.Parser.ProjectDomService.GetProjectDom (project);
return ctx.GetType (className, false, false);
}
