public static string GetStockIcon(this IUnresolvedEntity entity)
{
switch (entity.EntityType)
{
case EntityType.TypeDefinition:
return(GetStockIcon((IUnresolvedTypeDefinition)entity));
case EntityType.Field:
return(fieldIconTable [ModifierToOffset(entity.Accessibility)]);
case EntityType.Method:
case EntityType.Constructor:
case EntityType.Destructor:
case EntityType.Operator:
return(methodIconTable [ModifierToOffset(entity.Accessibility)]);
case EntityType.Property:
case EntityType.Indexer:
return(propertyIconTable [ModifierToOffset(entity.Accessibility)]);
case EntityType.Event:
return(eventIconTable [ModifierToOffset(entity.Accessibility)]);
}
return("");
}
public void AddMember(IUnresolvedEntity entity, Mono.Cecil.MemberReference cecilObject)
{
rwLock.EnterWriteLock();
try {
uint token = cecilObject.MetadataToken.ToUInt32();
metadataTokens[entity] = token;
var cecilMethod = cecilObject as Mono.Cecil.MethodDefinition;
if (cecilMethod != null) {
IUnresolvedMethod method = (IUnresolvedMethod)entity;
tokenToMethod[token] = method;
if (cecilMethod.HasBody) {
var locals = cecilMethod.Body.Variables;
if (locals.Count > 0) {
localVariableTypes[method] = locals.Select(v => typeRefLoader.ReadTypeReference(v.VariableType)).ToArray();
}
if (cecilMethod.RVA != 0) {
// The method was loaded from image - we can free the memory for the body
// because Cecil will re-initialize it on demand
cecilMethod.Body = null;
}
}
}
} finally {
rwLock.ExitWriteLock();
}
}
public DocumentationComment GetDocumentation(IUnresolvedEntity entity, IEntity resolvedEntity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (resolvedEntity == null)
{
throw new ArgumentNullException("resolvedEntity");
}
string xmlDoc = GetDocumentation(entity);
if (xmlDoc == null)
{
return(null);
}
var unresolvedTypeDef = entity as IUnresolvedTypeDefinition ?? entity.DeclaringTypeDefinition;
var resolvedTypeDef = resolvedEntity as ITypeDefinition ?? resolvedEntity.DeclaringTypeDefinition;
if (unresolvedTypeDef != null && resolvedTypeDef != null)
{
var context = unresolvedTypeDef.CreateResolveContext(new SimpleTypeResolveContext(resolvedTypeDef));
if (resolvedEntity is IMember)
{
context = context.WithCurrentMember((IMember)resolvedEntity);
}
return(new CSharpDocumentationComment(new StringTextSource(xmlDoc), context));
}
else
{
return(new DocumentationComment(new StringTextSource(xmlDoc), new SimpleTypeResolveContext(resolvedEntity)));
}
}
public void AddMember(IUnresolvedEntity entity, Mono.Cecil.MemberReference cecilObject)
{
rwLock.EnterWriteLock();
try {
uint token = cecilObject.MetadataToken.ToUInt32();
metadataTokens[entity] = token;
var cecilMethod = cecilObject as Mono.Cecil.MethodDefinition;
if (cecilMethod != null)
{
IUnresolvedMethod method = (IUnresolvedMethod)entity;
tokenToMethod[token] = method;
if (cecilMethod.HasBody)
{
var locals = cecilMethod.Body.Variables;
if (locals.Count > 0)
{
localVariableTypes[method] = locals.Select(v => typeRefLoader.ReadTypeReference(v.VariableType)).ToArray();
}
if (cecilMethod.RVA != 0)
{
// The method was loaded from image - we can free the memory for the body
// because Cecil will re-initialize it on demand
cecilMethod.Body = null;
}
}
}
} finally {
rwLock.ExitWriteLock();
}
}
static string GetAccess(IUnresolvedEntity entity)
{
switch (entity.Accessibility)
{
case Accessibility.None:
return("");
case Accessibility.Private:
return("private-");
case Accessibility.Public:
return("");
case Accessibility.Protected:
return("protected-");
case Accessibility.Internal:
return("internal-");
case Accessibility.ProtectedOrInternal:
case Accessibility.ProtectedAndInternal:
return("ProtectedOrInternal-");
default:
throw new ArgumentOutOfRangeException();
}
}
public EntityItem(IMember member, IAmbience ambience)
{
this.IsInSamePart = true;
this.entity = member.UnresolvedMember;
ambience.ConversionFlags = ConversionFlags.ShowTypeParameterList | ConversionFlags.ShowParameterList | ConversionFlags.ShowParameterNames;
text = ambience.ConvertSymbol(member);
image = CompletionImage.GetImage(member);
}
public EntityBookmark(IUnresolvedEntity entity, IDocument document)
{
this.entity = entity;
int lineNr = entity.Region.BeginLine;
if (document != null && lineNr > 0 && lineNr < document.LineCount) {
this.line = document.GetLineByNumber(lineNr);
}
}
/// <summary>
/// Gets the CompletionImage instance for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
switch (entity.SymbolKind)
{
case SymbolKind.TypeDefinition:
return(GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic));
case SymbolKind.Field:
IUnresolvedField field = (IUnresolvedField)entity;
if (field.IsConst)
{
if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
{
return(imageEnumValue);
}
else
{
return(imageLiteral);
}
}
return(field.IsReadOnly ? imageFieldReadOnly : imageField);
case SymbolKind.Method:
IUnresolvedMethod method = (IUnresolvedMethod)entity;
// We cannot reliably detect extension methods in the unresolved type system (e.g. in VB we need to resolve an attribute),
// but at least we can do it for C#:
var defMethod = method as DefaultUnresolvedMethod;
if (defMethod != null && defMethod.IsExtensionMethod)
{
return(imageExtensionMethod);
}
return(method.IsOverridable ? imageVirtualMethod : imageMethod);
case SymbolKind.Property:
return(imageProperty);
case SymbolKind.Indexer:
return(imageIndexer);
case SymbolKind.Event:
return(imageEvent);
case SymbolKind.Operator:
case SymbolKind.Destructor:
return(imageOperator);
case SymbolKind.Constructor:
return(imageConstructor);
default:
return(null);
}
}
public void AddDocumentation(IUnresolvedEntity entity, string xmlDocumentation)
{
FreezableHelper.ThrowIfFrozen(this);
if (documentation == null)
{
documentation = new Dictionary <IUnresolvedEntity, string>();
}
documentation.Add(entity, xmlDocumentation);
}
public uint GetMetadataToken(IUnresolvedEntity entity)
{
rwLock.EnterReadLock();
try {
return(metadataTokens[entity]);
} finally {
rwLock.ExitReadLock();
}
}
private IUnresolvedEntity SetDecl(IUnresolvedEntity unresolvedEntity, object decl)
{
if (decl == unresolvedEntity)
{
throw new System.Exception();
}
unresolvedEntity.Declaration = decl;
return(unresolvedEntity);
}
protected AbstractResolvedEntity(IUnresolvedEntity unresolved, ITypeResolveContext parentContext)
{
if (unresolved == null)
throw new ArgumentNullException("unresolved");
if (parentContext == null)
throw new ArgumentNullException("parentContext");
this.unresolved = unresolved;
this.parentContext = parentContext;
this.Attributes = unresolved.Attributes.CreateResolvedAttributes(parentContext);
}
ICompletionData ICompletionDataFactory.CreateEntityCompletionData(IUnresolvedEntity entity, string text)
{
var context = CSharpParsedFile.GetTypeResolveContext(Document.Compilation, document.Editor.Caret.Location);
var resolvedEntity = ((IUnresolvedMember)entity).CreateResolved(context);
return(new MemberCompletionData(this, resolvedEntity, OutputFlags.IncludeGenerics | OutputFlags.HideArrayBrackets | OutputFlags.IncludeParameterName)
{
HideExtensionParameter = true
});
}
public EntityBookmark(IUnresolvedEntity entity, IDocument document)
{
this.entity = entity;
int lineNr = entity.Region.BeginLine;
if (document != null && lineNr > 0 && lineNr < document.LineCount)
{
this.line = document.GetLineByNumber(lineNr);
}
}
/// <summary>
/// Retrieves the model instance for the given unresolved entity.
/// </summary>
/// <param name="entity">The unresolved entity</param>
/// <param name="project">The project in which the entity is defined.
/// If this parameter is null, the project will be determined based on the file name.</param>
/// <returns>The entity model if it could be found; or null otherwise.</returns>
public static IEntityModel GetModel(this IUnresolvedEntity entity, IProject project = null)
{
if (project == null)
{
if (entity.Region.FileName == null)
{
return(null);
}
project = SD.ProjectService.FindProjectContainingFile(FileName.Create(entity.Region.FileName));
if (project == null)
{
return(null);
}
}
IUnresolvedTypeDefinition unresolvedTypeDefinition = entity as IUnresolvedTypeDefinition ?? entity.DeclaringTypeDefinition;
if (unresolvedTypeDefinition == null)
{
return(null);
}
ITypeDefinitionModel typeModel = project.AssemblyModel.TopLevelTypeDefinitions[unresolvedTypeDefinition.FullTypeName];
if (entity is IUnresolvedTypeDefinition || typeModel == null)
{
return(typeModel);
}
ITypeDefinition typeDefinition = typeModel.Resolve();
IUnresolvedMember unresolvedMember = entity as IUnresolvedMember;
if (typeDefinition == null || unresolvedMember == null)
{
return(null);
}
IMember member = unresolvedMember.Resolve(new SimpleTypeResolveContext(typeDefinition));
if (member == null)
{
return(null);
}
var snapshot = member.Compilation.SolutionSnapshot as ISolutionSnapshotWithProjectMapping;
foreach (var memberModel in typeModel.Members)
{
if (memberModel.Name == unresolvedMember.Name)
{
if (memberModel.Resolve() == member.MemberDefinition)
{
return(memberModel);
}
}
}
return(null);
}
static bool NeedsDocumentation(TextEditorData data, IUnresolvedEntity member)
{
int lineNr = member.Region.BeginLine - 1;
DocumentLine line;
do
{
line = data.Document.GetLine(lineNr--);
} while (lineNr > 0 && data.Document.GetLineIndent(line).Length == line.Length);
return(!data.Document.GetTextAt(line).TrimStart().StartsWith("///", StringComparison.Ordinal));
}
MemberReference GetCecil(IUnresolvedEntity member)
{
lock (entityDict) {
MemberReference mr;
if (member != null && entityDict.TryGetValue(member, out mr))
{
return(mr);
}
return(null);
}
}
string GetString (Ambience amb, IUnresolvedEntity x)
{
var ctx = new SimpleTypeResolveContext (Document.Compilation.MainAssembly);
IEntity rx = null;
if (x is IUnresolvedMember)
rx = ((IUnresolvedMember)x).CreateResolved (ctx);
if (tag is IUnresolvedFile)
return amb.GetString (rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.UseFullInnerTypeName | OutputFlags.ReformatDelegates);
return amb.GetString (rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.ReformatDelegates);
}
/// <summary>
/// Creates a new QuickFix representing the non-bodyRegion
/// of the given region. Can be used to create QuickFixes
/// for AST members. The resulting QuickFix will then
/// contain the name and type signature of the member.
/// </summary>
/// <example>
/// For the region containing a "public string GetText(...)
/// {return null}" this method will return a QuickFix whose
/// Text is "public string GetText(...) ". So the returned
/// Text contains the type signature and not the body.
/// </example>
public static QuickFix ForNonBodyRegion(IUnresolvedEntity entity, IDocument document)
{
var text = GetNonBodyRegion
(entity.Region, document, entity.BodyRegion);
return new QuickFix
{ FileName = entity.Region.FileName
, Line = entity.Region.BeginLine
, Column = entity.Region.BeginColumn
, Text = text};
}
internal T GetCecilObject <T>(IUnresolvedEntity unresolvedEntity)
where T : IMemberDefinition
{
// this method has been made public in 3.0.0.3447 (see https://github.com/icsharpcode/ILSpy/issues/1028)
// TODO: get rid of reflection here once we migrate to that version
var getCecil = DecompilerTypeSystem.GetType().GetMethod("GetCecil", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
var cecilObject = getCecil.Invoke(DecompilerTypeSystem, new object[] { unresolvedEntity }) as MemberReference;
var resolved = (T)cecilObject.Resolve();
return(resolved);
}
public static string GetStockIcon(this IUnresolvedEntity entity, bool showAccessibility = true)
{
switch (entity.EntityType)
{
case EntityType.TypeDefinition:
return(GetStockIcon((IUnresolvedTypeDefinition)entity));
case EntityType.Field:
if (showAccessibility)
{
return(fieldIconTable [(int)entity.Accessibility]);
}
else
{
return(fieldIconTable [0]);
}
case EntityType.Method:
case EntityType.Constructor:
case EntityType.Destructor:
case EntityType.Operator:
if (showAccessibility)
{
return(methodIconTable [(int)entity.Accessibility]);
}
else
{
return(methodIconTable [0]);
}
case EntityType.Property:
case EntityType.Indexer:
if (showAccessibility)
{
return(propertyIconTable [(int)entity.Accessibility]);
}
else
{
return(propertyIconTable [0]);
}
case EntityType.Event:
if (showAccessibility)
{
return(eventIconTable [(int)entity.Accessibility]);
}
else
{
return(eventIconTable [0]);
}
}
return("");
}
static int GetTypeParameterCount(IUnresolvedEntity entity)
{
switch (entity)
{
case IUnresolvedTypeDefinition td:
return(td.TypeParameters.Count);
case IUnresolvedMethod method:
return(method.TypeParameters.Count);
}
return(0);
}
static string GetFormattedReturnType(IUnresolvedEntity entity)
{
string returnSignature = string.Empty;
var method = entity as AbstractUnresolvedMember;
if (method != null && method.ReturnType.ToString() != "void")
{
returnSignature = string.Format(" : {0}", method.ReturnType);
}
return(returnSignature);
}
MemberReference GetCecilObject(IUnresolvedEntity entity)
{
object cecilObj;
if (unresolvedTypeSystemToCecilDict.TryGetValue(entity, out cecilObj))
{
return(cecilObj as MemberReference);
}
else
{
return(null);
}
}
static string GetParameters(IUnresolvedEntity entity)
{
var info = string.Empty;
var method = entity as DefaultUnresolvedMethod;
if (method != null)
{
var typeInfo = method.Parameters.Select(p => p.Type.ToString());
info = string.Format("({0})", string.Join(", ", typeInfo));
}
return(info);
}
/// <summary>
/// Gets the image for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static ImageSource GetImage(IUnresolvedEntity entity)
{
CompletionImage image = GetCompletionImage(entity);
if (image != null)
{
return(image.GetImage(entity.Accessibility, entity.IsStatic));
}
else
{
return(null);
}
}
/// <summary>
/// Gets the index of member.
/// </summary>
/// <returns>The index of member.</returns>
/// <param name="member">Member.</param>
int GetIndexOfMember(IUnresolvedEntity member)
{
int i = 0;
for (i = 0; i < _cachedEntities.Count; i++)
{
if (_cachedEntities [i].Region == member.Region)
{
return(i);
}
}
return(-1);
}
/// <summary>
/// Creates a new QuickFix representing the non-bodyRegion
/// of the given region. Can be used to create QuickFixes
/// for AST members. The resulting QuickFix will then
/// contain the name and type signature of the member.
/// </summary>
/// <example>
/// For the region containing a "public string GetText(...)
/// {return null}" this method will return a QuickFix whose
/// Text is "public string GetText(...) ". So the returned
/// Text contains the type signature and not the body.
/// </example>
public static QuickFix ForNonBodyRegion
(IUnresolvedEntity entity, IDocument document)
{
var text = GetNonBodyRegion
(entity.Region, document, entity.BodyRegion);
return(new QuickFix
{
FileName = entity.Region.FileName
, Line = entity.Region.BeginLine
, Column = entity.Region.BeginColumn
, Text = text
});
}
/// <summary>
/// Gets the CompletionImage instance for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
switch (entity.SymbolKind)
{
case SymbolKind.TypeDefinition:
return(GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic));
case SymbolKind.Field:
IUnresolvedField field = (IUnresolvedField)entity;
if (field.IsConst)
{
if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
{
return(imageEnumValue);
}
else
{
return(imageLiteral);
}
}
return(field.IsReadOnly ? imageFieldReadOnly : imageField);
case SymbolKind.Method:
IUnresolvedMethod method = (IUnresolvedMethod)entity;
return(method.IsOverridable ? imageVirtualMethod : imageMethod);
case SymbolKind.Property:
return(imageProperty);
case SymbolKind.Indexer:
return(imageIndexer);
case SymbolKind.Event:
return(imageEvent);
case SymbolKind.Operator:
case SymbolKind.Destructor:
return(imageOperator);
case SymbolKind.Constructor:
return(imageConstructor);
default:
return(null);
}
}
protected ResolvedEntitySpec(IUnresolvedEntity unresolved, ITypeResolveContext parentContext)
{
if (unresolved == null)
{
throw new ArgumentNullException("unresolved");
}
if (parentContext == null)
{
throw new ArgumentNullException("parentContext");
}
this.unresolved = unresolved;
this.parentContext = parentContext;
this.Attributes = unresolved.Attributes.CreateResolvedAttributes(parentContext);
}
void okButtonClick(object sender, RoutedEventArgs e)
{
try {
if (listBox.SelectedItem == null)
{
return;
}
object tag = ((GotoEntry)listBox.SelectedItem).Tag;
if (tag is int)
{
ITextEditor editor = GetEditor();
if (editor != null)
{
int i = Math.Min(editor.Document.LineCount, Math.Max(1, (int)tag));
editor.JumpTo(i, int.MaxValue);
}
}
else if (tag is IUnresolvedEntity)
{
IUnresolvedEntity c = tag as IUnresolvedEntity;
CodeCompletionDataUsageCache.IncrementUsage(c.ReflectionName);
GotoRegion(c.Region);
}
else if (tag is IEntity)
{
IEntity m = tag as IEntity;
CodeCompletionDataUsageCache.IncrementUsage(m.ReflectionName);
GotoRegion(m.Region);
}
else if (tag is FileLineReference)
{
FileLineReference flref = (FileLineReference)tag;
if (flref.Line <= 0)
{
FileService.OpenFile(flref.FileName);
}
else
{
FileService.JumpToFilePosition(flref.FileName, flref.Line, flref.Column);
}
}
else
{
throw new NotImplementedException("Unknown tag: " + tag);
}
} finally {
Close();
}
}
void _treeView_Selection_Changed(object sender, EventArgs e)
{
var selectedRows = _treeView.Selection.GetSelectedRows();
if (selectedRows != null && selectedRows.Length > 0)
{
var row = selectedRows [0];
var index = row.Indices [0];
SelectedEntity = _filteredEntities [index];
_selectedIndex = index;
}
UpdateSrollPosition();
_searchView.GrabFocus();
_searchView.SelectRegion(_searchView.Text.Length, _searchView.Text.Length);
}
string GetString(Ambience amb, IUnresolvedEntity x)
{
var ctx = Document.ParsedDocument.ParsedFile.GetTypeResolveContext(Document.Compilation, x.Region.Begin);
IEntity rx = null;
if (x is IUnresolvedMember)
{
rx = ((IUnresolvedMember)x).CreateResolved(ctx);
}
if (tag is IParsedFile)
{
return(amb.GetString(rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.UseFullInnerTypeName | OutputFlags.ReformatDelegates));
}
return(amb.GetString(rx, OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters | OutputFlags.ReformatDelegates));
}
/// <summary>
/// Gets the next member after the specified caret position.
/// </summary>
IUnresolvedEntity GetMemberAfter(ITextEditor editor, int caretLine)
{
FileName fileName = editor.FileName;
IUnresolvedEntity nextElement = null;
if (fileName != null)
{
IUnresolvedFile unresolvedFile = SD.ParserService.ParseFile(fileName, editor.Document);
if (unresolvedFile != null)
{
var currentClass = unresolvedFile.GetInnermostTypeDefinition(caretLine, 0);
int nextElementLine = int.MaxValue;
if (currentClass == null)
{
foreach (var c in unresolvedFile.TopLevelTypeDefinitions)
{
if (c.Region.BeginLine < nextElementLine && c.Region.BeginLine > caretLine)
{
nextElementLine = c.Region.BeginLine;
nextElement = c;
}
}
}
else
{
foreach (var c in currentClass.NestedTypes)
{
if (c.Region.BeginLine < nextElementLine && c.Region.BeginLine > caretLine)
{
nextElementLine = c.Region.BeginLine;
nextElement = c;
}
}
foreach (var m in currentClass.Members)
{
if (m.Region.BeginLine < nextElementLine && m.Region.BeginLine > caretLine)
{
nextElementLine = m.Region.BeginLine;
nextElement = m;
}
}
}
}
}
return(nextElement);
}
static bool NeedsDocumentation(TextEditorData data, IUnresolvedEntity member)
{
int lineNr = member.Region.BeginLine;
DocumentLine line;
do
{
line = data.Document.GetLine(lineNr--);
}while (lineNr > 0 && data.Document.GetLineIndent(line).Length == line.Length);
int start = data.Document.GetLineIndent(line).Length;
if (start + 3 < line.Length && data.Document.GetTextAt(start, 3) == "///")
{
return(false);
}
return(true);
}
static string GetFormattedReturnType(IUnresolvedEntity entity)
{
string returnSignature = string.Empty;
var method = entity as AbstractUnresolvedMember;
if (method != null && method.ReturnType.ToString () != "void") {
returnSignature = string.Format (" : {0}", method.ReturnType);
}
return returnSignature;
}
ITreeNavigator SearchMember (IUnresolvedEntity member, bool expandNode = true)
{
return SearchMember (GetIdString (member), expandNode);
}
bool IsInsideType (IUnresolvedEntity currentType, TextLocation location)
{
var document = engine.document;
int startOffset = document.GetOffset (currentType.Region.Begin);
int endOffset = document.GetOffset (location);
bool foundEndBracket = false;
var bracketStack = new Stack<char> ();
bool isInString = false, isInChar = false;
bool isInLineComment = false, isInBlockComment = false;
for (int i = startOffset; i < endOffset; i++) {
char ch = document.GetCharAt (i);
switch (ch) {
case '(':
case '[':
case '{':
if (!isInString && !isInChar && !isInLineComment && !isInBlockComment)
bracketStack.Push (ch);
break;
case ')':
case ']':
case '}':
if (!isInString && !isInChar && !isInLineComment && !isInBlockComment)
if (bracketStack.Count > 0)
bracketStack.Pop ();
break;
case '\r':
case '\n':
isInLineComment = false;
break;
case '/':
if (isInBlockComment) {
if (i > 0 && document.GetCharAt (i - 1) == '*')
isInBlockComment = false;
} else if (!isInString && !isInChar && i + 1 < document.TextLength) {
char nextChar = document.GetCharAt (i + 1);
if (nextChar == '/')
isInLineComment = true;
if (!isInLineComment && nextChar == '*')
isInBlockComment = true;
}
break;
case '"':
if (!(isInChar || isInLineComment || isInBlockComment))
isInString = !isInString;
break;
case '\'':
if (!(isInString || isInLineComment || isInBlockComment))
isInChar = !isInChar;
break;
default :
break;
}
}
return bracketStack.Any (t => t == '{');
}
static string GetIdString (IUnresolvedEntity member)
{
StringBuilder sb;
switch (member.EntityType) {
case EntityType.TypeDefinition:
var type = member as IUnresolvedTypeDefinition;
if (type.TypeParameters.Count == 0)
return "T:" + type.FullName;
return "T:" + type.FullName + "`" + type.TypeParameters.Count;
case EntityType.Method:
var method = (IUnresolvedMethod)member;
sb = new StringBuilder ();
sb.Append ("M:");
sb.Append (method.FullName);
if (method.TypeParameters.Count > 0) {
sb.Append ("`");
sb.Append (method.TypeParameters.Count);
}
AppendHelpParameterList (sb, method.Parameters);
Console.WriteLine ("method:" + sb.ToString ());
return sb.ToString ();
case EntityType.Constructor:
var constructor = (IUnresolvedMethod)member;
sb = new StringBuilder ();
sb.Append ("M:");
sb.Append (constructor.DeclaringTypeDefinition.FullName);
sb.Append (".#ctor");
AppendHelpParameterList (sb, constructor.Parameters);
return sb.ToString ();
case EntityType.Destructor: // todo
return "todo";
case EntityType.Property:
return "P:" + member.FullName;
case EntityType.Indexer:
var indexer = (IUnresolvedProperty)member;
sb = new StringBuilder ();
sb.Append ("P:");
sb.Append (indexer.DeclaringTypeDefinition.FullName);
sb.Append (".Item");
AppendHelpParameterList (sb, indexer.Parameters);
return sb.ToString ();
case EntityType.Field:
case EntityType.Event:
return "F:" + member.FullName;
case EntityType.Operator: // todo
return "todo";
}
return "unknown entity: " + member;
}
MemberReference GetCecilObject(IUnresolvedEntity entity)
{
object cecilObj;
if (unresolvedTypeSystemToCecilDict.TryGetValue(entity, out cecilObj)) {
return cecilObj as MemberReference;
} else {
return null;
}
}
public static IImage GetIcon(IUnresolvedEntity entity)
{
return GetIImage(CompletionImage.GetImage(entity));
}
ITreeNavigator SearchMember (IUnresolvedEntity member)
{
return SearchMember (GetIdString (member));
}
public uint GetMetadataToken(IUnresolvedEntity entity)
{
rwLock.EnterReadLock();
try {
return metadataTokens[entity];
} finally {
rwLock.ExitReadLock();
}
}
/// <summary>
/// Gets the CompletionImage instance for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
{
if (entity == null)
throw new ArgumentNullException("entity");
switch (entity.SymbolKind) {
case SymbolKind.TypeDefinition:
return GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic);
case SymbolKind.Field:
IUnresolvedField field = (IUnresolvedField)entity;
if (field.IsConst) {
if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
return imageEnumValue;
else
return imageLiteral;
}
return field.IsReadOnly ? imageFieldReadOnly : imageField;
case SymbolKind.Method:
IUnresolvedMethod method = (IUnresolvedMethod)entity;
return method.IsOverridable ? imageVirtualMethod : imageMethod;
case SymbolKind.Property:
return imageProperty;
case SymbolKind.Indexer:
return imageIndexer;
case SymbolKind.Event:
return imageEvent;
case SymbolKind.Operator:
case SymbolKind.Destructor:
return imageOperator;
case SymbolKind.Constructor:
return imageConstructor;
default:
return null;
}
}
static string GetSource (IUnresolvedEntity entity)
{
switch (entity.SymbolKind) {
case SymbolKind.TypeDefinition:
var type = (IUnresolvedTypeDefinition)entity;
switch (type.Kind) {
case TypeKind.Class:
return "class";
case TypeKind.Interface:
return "interface";
case TypeKind.Struct:
return "struct";
case TypeKind.Delegate:
return "delegate";
case TypeKind.Enum:
return "enum";
}
return "class";
case SymbolKind.Field:
return "field";
case SymbolKind.Event:
return "event";
case SymbolKind.Method:
case SymbolKind.Constructor:
case SymbolKind.Destructor:
case SymbolKind.Operator:
return "method";
case SymbolKind.Property:
case SymbolKind.Indexer:
return "property";
}
return "";
}
static string GetGlobal (IUnresolvedEntity entity)
{
switch (entity.SymbolKind) {
case SymbolKind.Field:
var field = (IUnresolvedField)entity;
return field.IsStatic && !field.IsConst ? "static-" : "";
case SymbolKind.Method:
case SymbolKind.Constructor:
case SymbolKind.Destructor:
case SymbolKind.Operator:
case SymbolKind.Property:
case SymbolKind.Indexer:
return entity.IsStatic ? "static-" : "";
}
return "";
}
static string GetAccess (IUnresolvedEntity entity)
{
switch (entity.Accessibility) {
case Accessibility.None:
return "";
case Accessibility.Private:
return "private-";
case Accessibility.Public:
return "";
case Accessibility.Protected:
return "protected-";
case Accessibility.Internal:
return "internal-";
case Accessibility.ProtectedOrInternal:
case Accessibility.ProtectedAndInternal:
return "ProtectedOrInternal-";
default:
throw new ArgumentOutOfRangeException ();
}
}
static bool NeedsDocumentation (TextEditorData data, IUnresolvedEntity member)
{
int lineNr = member.Region.BeginLine;
DocumentLine line;
do {
line = data.Document.GetLine (lineNr--);
} while (lineNr > 0 && data.Document.GetLineIndent (line).Length == line.Length);
int start = data.Document.GetLineIndent (line).Length;
if (start + 3 < line.Length && data.Document.GetTextAt (start, 3) == "///")
return false;
return true;
}
void AddAttributes(FieldInfo fieldDefinition, IUnresolvedEntity targetEntity)
{
// FieldOffsetAttribute
int fOffset;
if (fieldDefinition.__TryGetFieldOffset(out fOffset)) {
var fieldOffset = new DefaultUnresolvedAttribute(fieldOffsetAttributeTypeRef, new[] { KnownTypeReference.Int32 });
fieldOffset.PositionalArguments.Add(CreateSimpleConstantValue(KnownTypeReference.Int32, fOffset));
targetEntity.Attributes.Add(interningProvider.Intern(fieldOffset));
}
// NonSerializedAttribute
if (fieldDefinition.IsNotSerialized) {
targetEntity.Attributes.Add(nonSerializedAttribute);
}
FieldMarshal marshal;
if (fieldDefinition.__TryGetFieldMarshal (out marshal))
targetEntity.Attributes.Add(ConvertMarshalInfo(marshal));
AddCustomAttributes(fieldDefinition.CustomAttributes, targetEntity.Attributes);
}
void AddAttributes(EventInfo eventDefinition, IUnresolvedEntity targetEntity)
{
AddCustomAttributes(eventDefinition.CustomAttributes, targetEntity.Attributes);
}
/// <summary>
/// Gets the CompletionImage instance for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static CompletionImage GetCompletionImage(IUnresolvedEntity entity)
{
if (entity == null)
throw new ArgumentNullException("entity");
switch (entity.SymbolKind) {
case SymbolKind.TypeDefinition:
return GetCompletionImageForType(((IUnresolvedTypeDefinition)entity).Kind, entity.IsStatic);
case SymbolKind.Field:
IUnresolvedField field = (IUnresolvedField)entity;
if (field.IsConst) {
if (field.DeclaringTypeDefinition != null && field.DeclaringTypeDefinition.Kind == TypeKind.Enum)
return imageEnumValue;
else
return imageLiteral;
}
return field.IsReadOnly ? imageFieldReadOnly : imageField;
case SymbolKind.Method:
IUnresolvedMethod method = (IUnresolvedMethod)entity;
// We cannot reliably detect extension methods in the unresolved type system (e.g. in VB we need to resolve an attribute),
// but at least we can do it for C#:
var defMethod = method as DefaultUnresolvedMethod;
if (defMethod != null && defMethod.IsExtensionMethod)
return imageExtensionMethod;
return method.IsOverridable ? imageVirtualMethod : imageMethod;
case SymbolKind.Property:
return imageProperty;
case SymbolKind.Indexer:
return imageIndexer;
case SymbolKind.Event:
return imageEvent;
case SymbolKind.Operator:
case SymbolKind.Destructor:
return imageOperator;
case SymbolKind.Constructor:
return imageConstructor;
default:
return null;
}
}
internal static string GetIdString (IUnresolvedEntity member)
{
StringBuilder sb;
switch (member.SymbolKind) {
case SymbolKind.TypeDefinition:
var type = member as IUnresolvedTypeDefinition;
if (type.TypeParameters.Count == 0)
return "T:" + type.FullName;
return "T:" + type.FullName + "`" + type.TypeParameters.Count;
case SymbolKind.Method:
var method = (IUnresolvedMethod)member;
sb = new StringBuilder ();
sb.Append ("M:");
sb.Append (method.DeclaringTypeDefinition.ReflectionName);
sb.Append (".");
sb.Append (method.Name);
if (method.TypeParameters.Count > 0) {
sb.Append ("`");
sb.Append (method.TypeParameters.Count);
}
AppendHelpParameterList (sb, method.Parameters);
return sb.ToString ();
case SymbolKind.Constructor:
var constructor = (IUnresolvedMethod)member;
sb = new StringBuilder ();
sb.Append ("M:");
sb.Append (constructor.DeclaringTypeDefinition.FullName);
sb.Append (".#ctor");
AppendHelpParameterList (sb, constructor.Parameters);
return sb.ToString ();
case SymbolKind.Destructor: // todo
return "todo";
case SymbolKind.Property:
sb = new StringBuilder ();
sb.Append ("P:");
sb.Append (member.DeclaringTypeDefinition.ReflectionName);
sb.Append (".");
sb.Append (member.Name);
return sb.ToString ();
case SymbolKind.Indexer:
var indexer = (IUnresolvedProperty)member;
sb = new StringBuilder ();
sb.Append ("P:");
sb.Append (indexer.DeclaringTypeDefinition.ReflectionName);
sb.Append (".Item");
AppendHelpParameterList (sb, indexer.Parameters);
return sb.ToString ();
case SymbolKind.Field:
sb = new StringBuilder ();
sb.Append ("F:");
sb.Append (member.DeclaringTypeDefinition.ReflectionName);
sb.Append (".");
sb.Append (member.Name);
return sb.ToString ();
case SymbolKind.Event:
sb = new StringBuilder ();
sb.Append ("E:");
sb.Append (member.DeclaringTypeDefinition.ReflectionName);
sb.Append (".");
sb.Append (member.Name);
return sb.ToString ();
case SymbolKind.Operator: // todo
return "todo";
}
return "unknown entity: " + member;
}
static string GetParameters(IUnresolvedEntity entity)
{
var info = string.Empty;
var method = entity as DefaultUnresolvedMethod;
if (method != null) {
var typeInfo = method.Parameters.Select (p => p.Type.ToString ());
info = string.Format ("({0})", string.Join (", ", typeInfo));
}
return info;
}
public KeyActions PreProcessKey(Gdk.Key key, char keyChar, Gdk.ModifierType modifier)
{
bool isSelected;
switch (key) {
case Gdk.Key.Home:
if ((modifier & ModifierType.ShiftMask) == ModifierType.ShiftMask)
return KeyActions.Process;
//TODO
return KeyActions.Ignore;
case Gdk.Key.End:
if ((modifier & ModifierType.ShiftMask) == ModifierType.ShiftMask)
return KeyActions.Process;
//TODO
return KeyActions.Ignore;
case Gdk.Key.Up:
if (_selectedIndex - 1 >= 0) {
SelectRowIndex (_selectedIndex - 1);
}
return KeyActions.Ignore;
case Gdk.Key.Tab:
//tab always completes current item even if selection is disabled
goto case Gdk.Key.Return;
//
case Gdk.Key.Return:
case Gdk.Key.ISO_Enter:
case Gdk.Key.Key_3270_Enter:
case Gdk.Key.KP_Enter:
if (_selectedEntry != null) {
return KeyActions.Complete | KeyActions.Ignore | KeyActions.CloseWindow;
}
return KeyActions.Ignore;
case Gdk.Key.Escape:
_selectedEntry = null;
return KeyActions.Ignore | KeyActions.CloseWindow;
case Gdk.Key.Down:
if (_selectedIndex + 1 < _filteredEntities.Count) {
SelectRowIndex (_selectedIndex + 1);
}
return KeyActions.Ignore;
case Gdk.Key.Page_Up:
if ((modifier & ModifierType.ShiftMask) == ModifierType.ShiftMask)
return KeyActions.Process;
//TODO
return KeyActions.Ignore;
case Gdk.Key.Page_Down:
if ((modifier & ModifierType.ShiftMask) == ModifierType.ShiftMask)
return KeyActions.Process;
//TODO
return KeyActions.Ignore;
case Gdk.Key.Left:
//if (curPos == 0) return KeyActions.CloseWindow | KeyActions.Process;
//curPos--;
return KeyActions.Process;
case Gdk.Key.Right:
//if (curPos == word.Length) return KeyActions.CloseWindow | KeyActions.Process;
//curPos++;
return KeyActions.Process;
case Gdk.Key.Caps_Lock:
case Gdk.Key.Num_Lock:
case Gdk.Key.Scroll_Lock:
return KeyActions.Ignore;
case Gdk.Key.Control_L:
case Gdk.Key.Control_R:
case Gdk.Key.Alt_L:
case Gdk.Key.Alt_R:
case Gdk.Key.Shift_L:
case Gdk.Key.Shift_R:
case Gdk.Key.ISO_Level3_Shift:
// AltGr
return KeyActions.Process;
default:
return KeyActions.Ignore;
}
if (keyChar == '\0')
return KeyActions.Process;
if (keyChar == ' ' && (modifier & ModifierType.ShiftMask) == ModifierType.ShiftMask)
return KeyActions.CloseWindow | KeyActions.Process;
// special case end with punctuation like 'param:' -> don't input double punctuation, otherwise we would end up with 'param::'
if (char.IsPunctuation (keyChar) && keyChar != '_') {
return KeyActions.Ignore;
}
return KeyActions.Process;
}
static bool NeedsDocumentation (TextEditorData data, IUnresolvedEntity member)
{
int lineNr = member.Region.BeginLine - 1;
DocumentLine line;
do {
line = data.Document.GetLine (lineNr--);
} while (lineNr > 0 && data.Document.GetLineIndent (line).Length == line.Length);
return !data.Document.GetTextAt (line).TrimStart ().StartsWith ("///", StringComparison.Ordinal);
}
/// <summary>
/// Gets the image for the specified entity.
/// Returns null when no image is available for the entity type.
/// </summary>
public static ImageSource GetImage(IUnresolvedEntity entity)
{
CompletionImage image = GetCompletionImage(entity);
if (image != null)
return image.GetImage(entity.Accessibility, entity.IsStatic);
else
return null;
}
void _treeView_Selection_Changed(object sender, EventArgs e)
{
var selectedRows = _treeView.Selection.GetSelectedRows ();
if (selectedRows != null && selectedRows.Length > 0) {
var row = selectedRows [0];
var index = row.Indices [0];
_selectedEntry = _filteredEntities [index];
_selectedIndex = index;
}
_searchView.GrabFocus ();
_searchView.SelectRegion (_searchView.Text.Length, _searchView.Text.Length);
}
void AddAttributes(PropertyInfo propertyDefinition, IUnresolvedEntity targetEntity)
{
AddCustomAttributes(propertyDefinition.CustomAttributes, targetEntity.Attributes);
}
void RegisterCecilObject(IUnresolvedEntity typeSystemObject, MemberInfo cecilObject)
{
if (OnEntityLoaded != null)
OnEntityLoaded(typeSystemObject, cecilObject);
}
