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); }