예제 #1
0
		static ImmutableList<string> GetNamespacesToReallyAdd(SyntaxNode relativeToNode, SemanticModel semanticModel,
			ImmutableHashSet<string> namespaceQualifiedStrings)
		{
			var alreadyInScope = semanticModel
				.GetUsingNamespacesInScope(relativeToNode)
				.Select(ns => ns.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))
				.ToImmutableHashSet();

			var toReallyAdd = namespaceQualifiedStrings
				.Where(ns => !alreadyInScope.Contains(ns))
				.ToImmutableList();

			return toReallyAdd;
		}
 protected override ISet<INamespaceSymbol> GetNamespacesInScope(
     SemanticModel semanticModel,
     SyntaxNode node,
     CancellationToken cancellationToken)
 {
     return semanticModel.GetUsingNamespacesInScope(node);
 }
예제 #3
0
		public static bool IsNamespaceInUsing(SemanticModel semanticModel, SyntaxNode forNode, INamespaceSymbol ns)
		{
			return semanticModel.GetUsingNamespacesInScope(forNode).Any(usingNamespace => usingNamespace.Equals(ns));
		}
		IEnumerable<IMethodSymbol> GetExtensionMethods (SemanticModel semanticModel, ITypeSymbol typeToExtend, InvocationExpressionSyntax node, CancellationToken cancellationToken)
		{
			var usedNamespaces = new HashSet<string> ();
			foreach (var un in semanticModel.GetUsingNamespacesInScope (node)) {
				usedNamespaces.Add (un.GetFullName ());
			}
			var enclosingNamespaceName = semanticModel.GetEnclosingNamespace (node.SpanStart, cancellationToken).GetFullName ();

			var stack = new Stack<INamespaceOrTypeSymbol> ();
			stack.Push (semanticModel.Compilation.GlobalNamespace);

			while (stack.Count > 0) {
				if (cancellationToken.IsCancellationRequested)
					break;
				var current = stack.Pop ();
				var currentNs = current as INamespaceSymbol;
				if (currentNs != null) {

					foreach (var member in currentNs.GetNamespaceMembers ()) {
						var currentNsName = member.GetFullName ();
						if (usedNamespaces.Contains (currentNsName) ||
							enclosingNamespaceName == currentNsName ||
							(enclosingNamespaceName.StartsWith (currentNsName, StringComparison.Ordinal) &&
							enclosingNamespaceName [currentNsName.Length] == '.')) {
							stack.Push (member);
						}
					}

					foreach (var member in currentNs.GetTypeMembers ())
						stack.Push (member);

				} else {
					var type = (INamedTypeSymbol)current;
					if (type.IsImplicitClass || type.IsScriptClass)
						continue;
					if (type.DeclaredAccessibility != Accessibility.Public) {
						if (type.DeclaredAccessibility != Accessibility.Internal)
							continue;
						if (!type.IsAccessibleWithin (semanticModel.Compilation.Assembly))
							continue;
					}
					if (!type.MightContainExtensionMethods)
						continue;
					foreach (var extMethod in type.GetMembers ().OfType<IMethodSymbol> ().Where (method => method.IsExtensionMethod)) {
						var reducedMethod = extMethod.ReduceExtensionMethod (typeToExtend);
						if (reducedMethod != null) {
							yield return reducedMethod;
						}
					}
				}
			}
		}