static int CompareUsings(IUsing a, IUsing b) { if (a.HasAliases != b.HasAliases) { return(a.HasAliases ? 1 : -1); } if (a.Usings.Count != 0 && b.Usings.Count != 0) { string u1 = a.Usings[0]; string u2 = b.Usings[0]; if (IsSystemNamespace(u1) && !IsSystemNamespace(u2)) { return(-1); } else if (!IsSystemNamespace(u1) && IsSystemNamespace(u2)) { return(1); } return(u1.CompareTo(u2)); } if (a.Aliases.Count != 0 && b.Aliases.Count != 0) { return(a.Aliases.Keys.First().CompareTo(b.Aliases.Keys.First())); } return(0); }
public static void AddUsing(ArrayList result, IUsing u, IProjectContent projectContent) { if (u == null) { return; } bool importNamespaces = projectContent.Language.ImportNamespaces; bool importClasses = projectContent.Language.CanImportClasses; foreach (string name in u.Usings) { if (importClasses) { IClass c = projectContent.GetClass(name, 0); if (c != null) { ArrayList members = new ArrayList(); IReturnType t = c.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); foreach (IMember m in members) { if (m.IsStatic && m.IsPublic) { result.Add(m); } } continue; } } if (importNamespaces) { string newName = null; if (projectContent.DefaultImports != null) { newName = projectContent.DefaultImports.SearchNamespace(name); } projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true); } else { foreach (object o in projectContent.GetNamespaceContents(name)) { if (!(o is string)) { result.Add(o); } } } } if (u.HasAliases) { foreach (string alias in u.Aliases.Keys) { result.Add(alias); } } }
public static FoldingRegion ToFold(this IEnumerable <IUsing> usings) { if (usings == null) { return(null); } var en = usings.GetEnumerator(); if (!en.MoveNext()) { return(null); } IUsing first = en.Current; IUsing last = first; while (en.MoveNext()) { if (en.Current.IsFromNamespace) { break; } last = en.Current; } if (first.Region.IsEmpty || last.Region.IsEmpty || first.Region.Start.Line == last.Region.End.Line) { return(null); } return(new FoldingRegion(new DomRegion(first.Region.Start, last.Region.End))); }
static int UsingComparer(IUsing left, IUsing right) { if (left.Aliases.Any() && right.Aliases.Any()) { return(left.Aliases.First().Key.CompareTo(right.Aliases.First().Key)); } if (left.Aliases.Any()) { return(1); } if (right.Aliases.Any()) { return(-1); } bool leftIsSystem = left.Namespaces.First().StartsWith("System"); bool rightIsSystem = right.Namespaces.First().StartsWith("System"); if (leftIsSystem && !rightIsSystem) { return(-1); } if (!leftIsSystem && rightIsSystem) { return(1); } return(left.Namespaces.First().CompareTo(right.Namespaces.First())); }
public virtual INode Visit(IUsing u, string data) { data += u.ToString() + "/"; foreach (KeyValuePair <string, IReturnType> val in u.Aliases) { val.Value.AcceptVisitor(this, data + "Aliases/"); } return(null); }
public override void AddGlobalNamespaceImport(RefactorerContext ctx, string fileName, string nsName) { IEditableTextFile file = ctx.GetFile(fileName); int pos = 0; ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text); StringBuilder text = new StringBuilder(); if (parsedDocument.CompilationUnit != null) { IUsing lastUsing = null; foreach (IUsing u in parsedDocument.CompilationUnit.Usings) { if (u.IsFromNamespace) { break; } lastUsing = u; } if (lastUsing != null) { pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column); } } if (pos != 0) { text.AppendLine(); } text.Append("using "); text.Append(nsName); text.Append(";"); if (file is Mono.TextEditor.ITextEditorDataProvider) { Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData(); if (pos == 0) { text.Append(data.EolMarker); } int caretOffset = data.Caret.Offset; int insertedChars = data.Insert(pos, text.ToString()); if (pos < caretOffset) { data.Caret.Offset = caretOffset + insertedChars; } } else { if (pos == 0) { text.AppendLine(); } file.InsertText(pos, text.ToString()); } }
static bool CheckImports(IUsing u) { if (u == null) { return(false); } else { return(u.Usings.Contains(NamespaceName)); } }
public virtual INode Visit(IUsing u, T data) { DomUsing result = new DomUsing(); result.Region = u.Region; result.IsFromNamespace = u.IsFromNamespace; foreach (string s in u.Namespaces) { result.Add(s); } foreach (KeyValuePair <string, IReturnType> val in u.Aliases) { result.Add(val.Key, val.Value); } return(result); }
public static UsingDeclaration ConvertUsing(IUsing u) { List <Using> usings = new List <Using>(); foreach (string name in u.Usings) { usings.Add(new Using(name)); } if (u.HasAliases) { foreach (KeyValuePair <string, IReturnType> pair in u.Aliases) { usings.Add(new Using(pair.Key, ConvertType(pair.Value, null))); } } return(new UsingDeclaration(usings)); }
static int UsingComparer (IUsing left, IUsing right) { if (left.Aliases.Any () && right.Aliases.Any ()) return left.Aliases.First ().Key.CompareTo (right.Aliases.First ().Key); if (left.Aliases.Any ()) return 1; if (right.Aliases.Any ()) return -1; bool leftIsSystem = left.Namespaces.First ().StartsWith ("System"); bool rightIsSystem = right.Namespaces.First ().StartsWith ("System"); if (leftIsSystem && !rightIsSystem) return -1; if (!leftIsSystem && rightIsSystem) return 1; return left.Namespaces.First ().CompareTo (right.Namespaces.First ()); }
static int CompareUsings(IUsing a, IUsing b) { if (a.HasAliases != b.HasAliases) return a.HasAliases ? 1 : -1; if (a.Usings.Count != 0 && b.Usings.Count != 0) { string u1 = a.Usings[0]; string u2 = b.Usings[0]; if (IsSystemNamespace(u1) && !IsSystemNamespace(u2)) { return -1; } else if (!IsSystemNamespace(u1) && IsSystemNamespace(u2)) { return 1; } return u1.CompareTo(u2); } if (a.Aliases.Count != 0 && b.Aliases.Count != 0) { return a.Aliases.Keys.First().CompareTo(b.Aliases.Keys.First()); } return 0; }
bool SearchTypeInUsing(IUsing u, SearchTypeRequest request, ref SearchTypeResult result) { foreach (IReturnType r in u.SearchType(request.Name, request.TypeParameterCount)) { result = new SearchTypeResult(r, u); if (MatchesRequest(request, ref result)) { return(true); } } string nsResult = u.SearchNamespace(request.Name); if (nsResult != null) { result = new SearchTypeResult(nsResult, null); if (MatchesRequest(request, ref result)) { return(true); } } return(false); }
/// <summary> /// <para>Returns the index of a <see cref='.IUsing'/> in /// the <see cref='.IUsingCollection'/> .</para> /// </summary> /// <param name='value'>The <see cref='.IUsing'/> to locate.</param> /// <returns> /// <para>The index of the <see cref='.IUsing'/> of <paramref name='value'/> in the /// <see cref='.IUsingCollection'/>, if found; otherwise, -1.</para> /// </returns> /// <seealso cref='.IUsingCollection.Contains'/> public int IndexOf(IUsing value) { return List.IndexOf(value); }
/// <summary> /// <para>Gets a value indicating whether the /// <see cref='.IUsingCollection'/> contains the specified <see cref='.IUsing'/>.</para> /// </summary> /// <param name='value'>The <see cref='.IUsing'/> to locate.</param> /// <returns> /// <para><see langword='true'/> if the <see cref='.IUsing'/> is contained in the collection; /// otherwise, <see langword='false'/>.</para> /// </returns> /// <seealso cref='.IUsingCollection.IndexOf'/> public bool Contains(IUsing value) { return List.Contains(value); }
void AddNamespaceImport(IUsing import) { AddCodeElement(new CodeImport(import)); }
public IClass SearchType(IUsing iusing, string partitialTypeName, bool caseSensitive) { return pdb.SearchType (db, iusing, partitialTypeName, caseSensitive); }
public static void AddUsing(List<ICompletionEntry> result, IUsing u, IProjectContent projectContent) { if (u == null) { return; } bool importNamespaces = projectContent.Language.ImportNamespaces; bool importClasses = projectContent.Language.CanImportClasses; foreach (string name in u.Usings) { if (importClasses) { IClass c = projectContent.GetClass(name, 0); if (c != null) { ArrayList members = new ArrayList(); IReturnType t = c.DefaultReturnType; members.AddRange(t.GetMethods()); members.AddRange(t.GetFields()); members.AddRange(t.GetEvents()); members.AddRange(t.GetProperties()); foreach (IMember m in members) { if (m.IsStatic && m.IsPublic) { result.Add(m); } } continue; } } if (importNamespaces) { string newName = null; if (projectContent.DefaultImports != null) { newName = projectContent.DefaultImports.SearchNamespace(name); } projectContent.AddNamespaceContents(result, newName ?? name, projectContent.Language, true); } else { foreach (ICompletionEntry o in projectContent.GetNamespaceContents(name)) { if (!(o is NamespaceEntry)) result.Add(o); } } } if (u.HasAliases) { foreach (string alias in u.Aliases.Keys) { result.Add(new AliasEntry(alias)); } } }
public void AddAtTop(IUsing newUsing) { usings.Insert(0, newUsing); }
public CodeImport(IUsing import) { this.import = import; this.Namespace = GetNamespace(); }
public SearchTypeResult(IReturnType result, IUsing usedUsing) { this.result = result; this.usedUsing = usedUsing; }
public string Visit(IUsing u, OutputSettings settings) { return("NOT IMPLEMENTED"); }
static bool CheckImports(IUsing u) { if (u == null) return false; else return u.Usings.Contains(NamespaceName); }
/// <summary> /// <para> Removes a specific <see cref='.IUsing'/> from the /// <see cref='.IUsingCollection'/> .</para> /// </summary> /// <param name='value'>The <see cref='.IUsing'/> to remove from the <see cref='.IUsingCollection'/> .</param> /// <returns><para>None.</para></returns> /// <exception cref='System.ArgumentException'><paramref name='value'/> is not found in the Collection. </exception> public void Remove(IUsing value) { List.Remove(value); }
public virtual S Visit(IUsing u, T data) { return(default(S)); }
/// <summary> /// <para>Adds a <see cref='.IUsing'/> with the specified value to the /// <see cref='.IUsingCollection'/> .</para> /// </summary> /// <param name='value'>The <see cref='.IUsing'/> to add.</param> /// <returns> /// <para>The index at which the new element was inserted.</para> /// </returns> /// <seealso cref='.IUsingCollection.AddRange'/> public int Add(IUsing value) { return List.Add(value); }
public SearchTypeResult(IReturnType result, IUsing usedUsing) { _result = result; _usedUsing = usedUsing; }
public static UsingDirectiveSyntax Create(IUsing element) => SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(element.Name));
IType SearchType(IUsing iusing, string partitialTypeName, IList <IReturnType> genericArguments, bool caseSensitive) { IType c = GetType(partitialTypeName, genericArguments, false, caseSensitive); if (c != null) { return(c); } foreach (string str in iusing.Namespaces) { string possibleType = String.Concat(str, ".", partitialTypeName); c = GetType(possibleType, genericArguments, false, caseSensitive); if (c != null) { return(c); } } IReturnType alias; // search class in partial namespaces if (iusing.Aliases.TryGetValue("", out alias)) { string declaringNamespace = alias.FullName; while (declaringNamespace.Length > 0) { string className = String.Concat(declaringNamespace, ".", partitialTypeName); c = GetType(className, genericArguments, false, caseSensitive); if (c != null) { return(c); } int index = declaringNamespace.IndexOf('.'); if (index > 0) { declaringNamespace = declaringNamespace.Substring(0, index); } else { break; } } } foreach (string aliasString in iusing.Aliases.Keys) { if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower())) { string className = null; if (aliasString.Length > 0) { IReturnType rt = iusing.Aliases [aliasString]; className = String.Concat(rt.FullName, partitialTypeName.Remove(0, aliasString.Length)); c = GetType(className, genericArguments, false, caseSensitive); if (c != null) { return(c); } } } } return(null); }
bool SearchTypeInUsing(IUsing u, SearchTypeRequest request, ref SearchTypeResult result) { foreach (IReturnType r in u.SearchType(request.Name, request.TypeParameterCount)) { result = new SearchTypeResult(r, u); if (MatchesRequest(request, ref result)) { return true; } } string nsResult = u.SearchNamespace(request.Name); if (nsResult != null) { result = new SearchTypeResult(nsResult, null); if (MatchesRequest(request, ref result)) { return true; } } return false; }
public string SearchNamespace(CodeCompletionDatabase db, IUsing usin, string partitialNamespaceName) { return SearchNamespace (db, usin, partitialNamespaceName, true); }
public override void AddLocalNamespaceImport(RefactorerContext ctx, string fileName, string nsName, DomLocation caretLocation) { IEditableTextFile file = ctx.GetFile(fileName); int pos = 0; ParsedDocument parsedDocument = parser.Parse(ctx.ParserContext, fileName, file.Text); StringBuilder text = new StringBuilder(); string indent = ""; if (parsedDocument.CompilationUnit != null) { IUsing containingUsing = null; foreach (IUsing u in parsedDocument.CompilationUnit.Usings) { if (u.IsFromNamespace && u.Region.Contains(caretLocation)) { containingUsing = u; } } if (containingUsing != null) { indent = GetLineIndent(file, containingUsing.Region.Start.Line); IUsing lastUsing = null; foreach (IUsing u in parsedDocument.CompilationUnit.Usings) { if (u == containingUsing) { continue; } if (containingUsing.Region.Contains(u.Region)) { if (u.IsFromNamespace) { break; } lastUsing = u; } } if (lastUsing != null) { pos = file.GetPositionFromLineColumn(lastUsing.Region.End.Line, lastUsing.Region.End.Column); } else { pos = file.GetPositionFromLineColumn(containingUsing.ValidRegion.Start.Line, containingUsing.ValidRegion.Start.Column); // search line end while (pos < file.Length) { char ch = file.GetCharAt(pos); if (ch == '\n') { if (file.GetCharAt(pos + 1) == '\r') { pos++; } break; } else if (ch == '\r') { break; } pos++; } } } else { AddGlobalNamespaceImport(ctx, fileName, nsName); return; } } if (pos != 0) { text.AppendLine(); } text.Append(indent); text.Append("\t"); text.Append("using "); text.Append(nsName); text.Append(";"); if (file is Mono.TextEditor.ITextEditorDataProvider) { Mono.TextEditor.TextEditorData data = ((Mono.TextEditor.ITextEditorDataProvider)file).GetTextEditorData(); if (pos == 0) { text.Append(data.EolMarker); } int caretOffset = data.Caret.Offset; int insertedChars = data.Insert(pos, text.ToString()); if (pos < caretOffset) { data.Caret.Offset = caretOffset + insertedChars; } } else { if (pos == 0) { text.AppendLine(); } file.InsertText(pos, text.ToString()); } }
public IClass SearchType(IUsing iusing, string partitialTypeName) { return pdb.SearchType (db, iusing, partitialTypeName); }
public SearchTypeResult(IReturnType result, IUsing usedUsing) { this.result = result; this.usedUsing = usedUsing; this.namespaceResult = null; }
/// <summary> /// <para>Copies the elements of an array to the end of the <see cref='.IUsingCollection'/>.</para> /// </summary> /// <param name='value'> /// An array of type <see cref='.IUsing'/> containing the objects to add to the collection. /// </param> /// <returns> /// <para>None.</para> /// </returns> /// <seealso cref='.IUsingCollection.Add'/> public void AddRange(IUsing[] value) { for (int i = 0; (i < value.Length); i = (i + 1)) { this.Add(value[i]); } }
public IClass SearchType(CodeCompletionDatabase db, IUsing iusing, string partitialTypeName, bool caseSensitive) { // Runtime.LoggingService.Info("Search type : >{0}<", partitialTypeName); IClass c = GetClass (db, partitialTypeName, caseSensitive); if (c != null) { return c; } foreach (string str in iusing.Usings) { string possibleType = String.Concat(str, ".", partitialTypeName); // Runtime.LoggingService.Info("looking for " + possibleType); c = GetClass (db, possibleType, caseSensitive); if (c != null) { // Runtime.LoggingService.Info("Found!"); return c; } } // search class in partitial namespaces string declaringNamespace = (string)iusing.Aliases[""]; if (declaringNamespace != null) { while (declaringNamespace.Length > 0) { string className = String.Concat(declaringNamespace, ".", partitialTypeName); // Runtime.LoggingService.Info("looking for " + className); c = GetClass (db, className, caseSensitive); if (c != null) { // Runtime.LoggingService.Info("Found!"); return c; } int index = declaringNamespace.IndexOf('.'); if (index > 0) { declaringNamespace = declaringNamespace.Substring(0, index); } else { break; } } } foreach (DictionaryEntry entry in iusing.Aliases) { string aliasString = entry.Key.ToString(); if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower())) { string className = null; if (aliasString.Length > 0) { className = String.Concat(entry.Value.ToString(), partitialTypeName.Remove(0, aliasString.Length)); // Runtime.LoggingService.Info("looking for " + className); c = GetClass (db, className, caseSensitive); if (c != null) { // Runtime.LoggingService.Info("Found!"); return c; } } } } return null; }
/// <summary> /// <para>Copies the <see cref='.IUsingCollection'/> values to a one-dimensional <see cref='System.Array'/> instance at the /// specified index.</para> /// </summary> /// <param name='array'><para>The one-dimensional <see cref='System.Array'/> that is the destination of the values copied from <see cref='.IUsingCollection'/> .</para></param> /// <param name='index'>The index in <paramref name='array'/> where copying begins.</param> /// <returns> /// <para>None.</para> /// </returns> /// <exception cref='System.ArgumentException'><para><paramref name='array'/> is multidimensional.</para> <para>-or-</para> <para>The number of elements in the <see cref='.IUsingCollection'/> is greater than the available space between <paramref name='arrayIndex'/> and the end of <paramref name='array'/>.</para></exception> /// <exception cref='System.ArgumentNullException'><paramref name='array'/> is <see langword='null'/>. </exception> /// <exception cref='System.ArgumentOutOfRangeException'><paramref name='arrayIndex'/> is less than <paramref name='array'/>'s lowbound. </exception> /// <seealso cref='System.Array'/> public void CopyTo(IUsing[] array, int index) { List.CopyTo(array, index); }
public string SearchNamespace(IUsing iusing, string partitialNamespaceName, bool caseSensitive) { return pdb.SearchNamespace (db, iusing, partitialNamespaceName, caseSensitive); }
/// <summary> /// <para>Inserts a <see cref='.IUsing'/> into the <see cref='.IUsingCollection'/> at the specified index.</para> /// </summary> /// <param name='index'>The zero-based index where <paramref name='value'/> should be inserted.</param> /// <param name=' value'>The <see cref='.IUsing'/> to insert.</param> /// <returns><para>None.</para></returns> /// <seealso cref='.IUsingCollection.Add'/> public void Insert(int index, IUsing value) { List.Insert(index, value); }
public SearchTypeResult(string namespaceResult, IUsing usedUsing) { this.result = null; this.usedUsing = usedUsing; this.namespaceResult = namespaceResult; }
/// <summary> /// <para> /// Initializes a new instance of <see cref='.IUsingCollection'/> containing any array of <see cref='.IUsing'/> objects. /// </para> /// </summary> /// <param name='value'> /// A array of <see cref='.IUsing'/> objects with which to intialize the collection /// </param> public IUsingCollection(IUsing[] value) { this.AddRange(value); }
public IClass SearchType(CodeCompletionDatabase db, IUsing iusing, string partitialTypeName) { return SearchType (db, iusing, partitialTypeName, true); }
public void Add(IUsing newUsing) { usings.Add(newUsing); }
public string SearchNamespace(CodeCompletionDatabase db, IUsing usin, string partitialNamespaceName, bool caseSensitive) { // Runtime.LoggingService.Info("SearchNamespace : >{0}<", partitialNamespaceName); if (NamespaceExists (db, partitialNamespaceName, caseSensitive)) { return partitialNamespaceName; } // search for partitial namespaces string declaringNamespace = (string)usin.Aliases[""]; if (declaringNamespace != null) { while (declaringNamespace.Length > 0) { if ((caseSensitive ? declaringNamespace.EndsWith(partitialNamespaceName) : declaringNamespace.ToLower().EndsWith(partitialNamespaceName.ToLower()) ) && NamespaceExists (db, declaringNamespace, caseSensitive)) { return declaringNamespace; } int index = declaringNamespace.IndexOf('.'); if (index > 0) { declaringNamespace = declaringNamespace.Substring(0, index); } else { break; } } } // Remember: // Each namespace has an own using object // The namespace name is an alias which has the key "" foreach (DictionaryEntry entry in usin.Aliases) { string aliasString = entry.Key.ToString(); if (caseSensitive ? partitialNamespaceName.StartsWith(aliasString) : partitialNamespaceName.ToLower().StartsWith(aliasString.ToLower())) { if (aliasString.Length >= 0) { string nsName = nsName = String.Concat(entry.Value.ToString(), partitialNamespaceName.Remove(0, aliasString.Length)); if (NamespaceExists (db, nsName, caseSensitive)) { return nsName; } } } } return null; }
IType SearchType (IUsing iusing, string partitialTypeName, IList<IReturnType> genericArguments, bool caseSensitive) { IType c = GetType (partitialTypeName, genericArguments, false, caseSensitive); if (c != null) { return c; } foreach (string str in iusing.Namespaces) { string possibleType = String.Concat(str, ".", partitialTypeName); c = GetType (possibleType, genericArguments, false, caseSensitive); if (c != null) return c; } IReturnType alias; // search class in partial namespaces if (iusing.Aliases.TryGetValue ("", out alias)) { string declaringNamespace = alias.FullName; while (declaringNamespace.Length > 0) { string className = String.Concat(declaringNamespace, ".", partitialTypeName); c = GetType (className, genericArguments, false, caseSensitive); if (c != null) return c; int index = declaringNamespace.IndexOf('.'); if (index > 0) { declaringNamespace = declaringNamespace.Substring(0, index); } else { break; } } } foreach (string aliasString in iusing.Aliases.Keys) { if (caseSensitive ? partitialTypeName.StartsWith(aliasString) : partitialTypeName.ToLower().StartsWith(aliasString.ToLower())) { string className = null; if (aliasString.Length > 0) { IReturnType rt = iusing.Aliases [aliasString]; className = String.Concat (rt.FullName, partitialTypeName.Remove (0, aliasString.Length)); c = GetType (className, genericArguments, false, caseSensitive); if (c != null) return c; } } } return null; }
public UsingHelper() { Using = MockRepository.GenerateStub <IUsing>(); Using.Stub(u => u.Usings).Return(Namespaces); }
public string Visit(IUsing u, OutputSettings settings) { return("TODO"); }
public string SearchNamespace(IUsing iusing, string partitialNamespaceName) { return pdb.SearchNamespace (db, iusing, partitialNamespaceName); }