/// <summary> /// Gets a fully formed using statement expanding any abbreviated statement beginning with using and ending with a semicolon. /// </summary> /// <param name="directive"> /// The directive to use. /// </param> /// <returns> /// The qualified using statement. /// </returns> internal static string GetFullyQualifiedStatement(this IUsingDirective directive) { if (directive is IUsingAliasDirective) { IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective; return(string.Format("using {0} = {1};", aliasDirective.AliasName, directive.GetFullyQualifiedNamespace())); } IUsingNamespaceDirective namespaceDirective = directive as IUsingNamespaceDirective; return(namespaceDirective != null?string.Format("using {0};", directive.GetFullyQualifiedNamespace()) : directive.GetText()); }
/// <summary> /// Compares the IUsingDirectives provided. /// </summary> /// <param name="usingDirectiveA"> /// The first Using Directive. /// </param> /// <param name="usingDirectiveB"> /// The second Using Directive. /// </param> /// <returns> /// An integer indicating the comparison. /// </returns> public int Compare(IUsingDirective usingDirectiveA, IUsingDirective usingDirectiveB) { bool usingDirectiveAIsAlias = usingDirectiveA is IUsingAliasDirective; bool usingDirectiveBIsAlias = usingDirectiveB is IUsingAliasDirective; if (usingDirectiveAIsAlias && !usingDirectiveBIsAlias) { return(1); } if (!usingDirectiveAIsAlias && usingDirectiveBIsAlias) { return(-1); } if (usingDirectiveAIsAlias) { IUsingAliasDirective usingAliasDirectiveA = usingDirectiveA as IUsingAliasDirective; IUsingAliasDirective usingAliasDirectiveB = usingDirectiveB as IUsingAliasDirective; if (usingAliasDirectiveA != null) { if (usingAliasDirectiveB != null) { return(string.Compare(usingAliasDirectiveA.AliasName, usingAliasDirectiveB.AliasName, StringComparison.OrdinalIgnoreCase)); } } } string usingNamespaceDirectiveAQualifiedNamespace = usingDirectiveA.GetFullyQualifiedNamespace(); string usingNamespaceDirectiveBQualifiedNamespace = usingDirectiveB.GetFullyQualifiedNamespace(); bool usingNamespaceDirectiveATextStartsWithSystem = usingNamespaceDirectiveAQualifiedNamespace.StartsWith("System"); bool usingNamespaceDirectiveBTextStartsWithSystem = usingNamespaceDirectiveBQualifiedNamespace.StartsWith("System"); if (usingNamespaceDirectiveATextStartsWithSystem && !usingNamespaceDirectiveBTextStartsWithSystem) { return(-1); } if (!usingNamespaceDirectiveATextStartsWithSystem && usingNamespaceDirectiveBTextStartsWithSystem) { return(1); } return(string.Compare( usingNamespaceDirectiveAQualifiedNamespace.SubstringBefore(';'), usingNamespaceDirectiveBQualifiedNamespace.SubstringBefore(';'), StringComparison.OrdinalIgnoreCase)); }
private static void ProcessImports( IList <IUsingDirective> newImportsList, AlphabeticalUsingsStyle organiseUsingsFormatOption, ExpandUsingsStyle expandUsingsFormatOption, ICSharpTypeAndNamespaceHolderDeclaration declaration) { if (newImportsList == null || newImportsList.Count == 0) { return; } List <IUsingDirective> arrayList = new List <IUsingDirective>(); arrayList.AddRange(newImportsList); if (organiseUsingsFormatOption == AlphabeticalUsingsStyle.Alphabetical) { arrayList.Sort(new UsingStatementSorter()); } foreach (IUsingDirective directive in arrayList) { IUsingDirective newUsingDirective; if (expandUsingsFormatOption == ExpandUsingsStyle.FullyQualify) { if (directive is IUsingAliasDirective) { IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective; newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()) .CreateUsingDirective(aliasDirective.AliasName + " = " + directive.GetFullyQualifiedNamespace()); IUsingAliasDirective n = newUsingDirective as IUsingAliasDirective; n.SetImportedSymbolName(aliasDirective.ImportedSymbolName); } else { newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()).CreateUsingDirective(directive.GetFullyQualifiedNamespace()); } } else { newUsingDirective = directive.CopyWithResolve(); } declaration.RemoveImport(directive); declaration.AddImportBefore(newUsingDirective, null); } }
/// <summary> /// Gets the full namespace for the Using directive with any aliases expanded. /// </summary> /// <param name="directive"> /// The directive to use. /// </param> /// <returns> /// The fully qualified namespace. /// </returns> internal static string GetFullyQualifiedNamespace(this IUsingDirective directive) { if (directive is IUsingAliasDirective) { IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective; INamespace aliasedNamespace = aliasDirective.DeclaredElement.GetAliasedNamespace(); string returnValue = aliasedNamespace == null ? aliasDirective.ImportedSymbolName.QualifiedName : aliasedNamespace.QualifiedName; return(returnValue); } IUsingNamespaceDirective namespaceDirective = directive as IUsingNamespaceDirective; return(namespaceDirective.ImportedNamespace == null ? namespaceDirective.ImportedSymbolName.QualifiedName : namespaceDirective.ImportedNamespace.QualifiedName); }
/// <summary> /// Gets the full namespace for the Using directive with any aliases expanded. /// </summary> /// <param name="directive"> /// The directive to use. /// </param> /// <returns> /// The fully qualified namespace. /// </returns> internal static string GetFullyQualifiedNamespace(this IUsingDirective directive) { if (directive is IUsingAliasDirective) { IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective; DeclaredElementInstance <IDeclaredElement> declaredElementInstance = aliasDirective.DeclaredElement.GetAliasedSymbol(); INamespace aliasedNamespace = declaredElementInstance == null ? null : declaredElementInstance.Element as INamespace; string returnValue = aliasedNamespace == null ? aliasDirective.ImportedSymbolName.QualifiedName : aliasedNamespace.QualifiedName; return(returnValue); } return(directive.ImportedSymbolName.QualifiedName); }
private static void ProcessImports( IList <IUsingDirective> originalImportsList, bool organiseUsings, bool expandUsings, ICSharpTypeAndNamespaceHolderDeclaration declaration) { if (originalImportsList == null || originalImportsList.Count == 0) { return; } List <IUsingDirective> sortedImportsList = new List <IUsingDirective>(); sortedImportsList.AddRange(originalImportsList); if (organiseUsings) { sortedImportsList.Sort(new UsingStatementSorter()); } bool alreadySorted = true; bool alreadyExpanded = true; for (int i = 0; i < originalImportsList.Count; i++) { if (originalImportsList[i] != sortedImportsList[i]) { alreadySorted = false; break; } IUsingAliasDirective aliasDirective = originalImportsList[i] as IUsingAliasDirective; if (aliasDirective != null) { if (aliasDirective.ImportedSymbolName.GetText() != aliasDirective.GetFullyQualifiedNamespace()) { alreadyExpanded = false; break; } } } if (alreadySorted && alreadyExpanded) { return; } foreach (IUsingDirective directive in sortedImportsList) { IUsingDirective newUsingDirective; if (expandUsings) { if (directive is IUsingAliasDirective) { IUsingAliasDirective aliasDirective = directive as IUsingAliasDirective; newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()) .CreateUsingDirective(aliasDirective.AliasName + " = " + directive.GetFullyQualifiedNamespace()); IUsingAliasDirective n = newUsingDirective as IUsingAliasDirective; n.SetImportedSymbolName(aliasDirective.ImportedSymbolName); } else { newUsingDirective = CSharpElementFactory.GetInstance(declaration.GetPsiModule()).CreateUsingDirective(directive.GetFullyQualifiedNamespace()); } } else { newUsingDirective = directive.CopyWithResolve(); } declaration.RemoveImport(directive); declaration.AddImportBefore(newUsingDirective, null); } }