private static SyntaxNode CalculateNewRoot(SyntaxNode root, ForEachStatementSyntax foreachSyntax, SemanticModel semanticModel) { var collection = foreachSyntax.Expression; var typeName = foreachSyntax.Type.ToString(); var invocationToAdd = GetOfTypeInvocation(typeName, collection); var namedTypes = semanticModel.LookupNamespacesAndTypes(foreachSyntax.SpanStart).OfType<INamedTypeSymbol>(); var isUsingAlreadyThere = namedTypes.Any(nt => nt.ToDisplayString() == ofTypeExtensionClass); if (isUsingAlreadyThere) { return root .ReplaceNode(collection, invocationToAdd) .WithAdditionalAnnotations(Formatter.Annotation); } else { var usingDirectiveToAdd = SyntaxFactory.UsingDirective( SyntaxFactory.QualifiedName( SyntaxFactory.IdentifierName("System"), SyntaxFactory.IdentifierName("Linq"))); var annotation = new SyntaxAnnotation("CollectionToChange"); var newRoot = root.ReplaceNode( collection, collection.WithAdditionalAnnotations(annotation)); var node = newRoot.GetAnnotatedNodes(annotation).First(); var closestNamespaceWithUsing = node.AncestorsAndSelf() .OfType<NamespaceDeclarationSyntax>() .FirstOrDefault(n => n.Usings.Count > 0); if (closestNamespaceWithUsing != null) { newRoot = newRoot.ReplaceNode( closestNamespaceWithUsing, closestNamespaceWithUsing.AddUsings(usingDirectiveToAdd)) .WithAdditionalAnnotations(Formatter.Annotation); } else { var compilationUnit = node.FirstAncestorOrSelf<CompilationUnitSyntax>(); newRoot = compilationUnit.AddUsings(usingDirectiveToAdd); } node = newRoot.GetAnnotatedNodes(annotation).First(); return newRoot .ReplaceNode(node, invocationToAdd) .WithAdditionalAnnotations(Formatter.Annotation); } }
public override string GetFullyQualifiedName(string name, int position, SemanticModel semanticModel) { var typeName = SyntaxFactory.ParseTypeName(name); if (typeName is PredefinedTypeSyntax) { PredefinedType predefinedType; if (SyntaxFactsService.TryGetPredefinedType(((PredefinedTypeSyntax)typeName).Keyword, out predefinedType)) { var specialType = predefinedType.ToSpecialType(); return semanticModel.Compilation.GetSpecialType(specialType).GetEscapedFullName(); } } else { var symbols = semanticModel.LookupNamespacesAndTypes(position, name: name); if (symbols.Length > 0) { return symbols[0].GetEscapedFullName(); } } return name; }
private static bool NamespaceNeedsToBeAdded(MethodDeclarationSyntax method, SemanticModel semanticModel, string LiteralNotSupportedException, string LiteralSystem) { return !semanticModel.LookupNamespacesAndTypes(method.Body.CloseBraceToken.SpanStart) .OfType<INamedTypeSymbol>() .Any(nt => nt.IsType && nt.Name == LiteralNotSupportedException && nt.ContainingNamespace.Name == LiteralSystem); }
public void AddImportCompletionData (CompletionResult result, Document document, SemanticModel semanticModel, int position, CancellationToken cancellationToken = default(CancellationToken)) { var ns = new Stack<INamespaceOrTypeSymbol>(); ns.Push(semanticModel.Compilation.GlobalNamespace); semanticModel.LookupNamespacesAndTypes(position); }
// // private static bool TryReplaceWithAlias(this ExpressionSyntax node, SemanticModel semanticModel, bool preferAliasToQualifiedName, CancellationToken cancellationToken, out IAliasSymbol aliasReplacement) // { // aliasReplacement = null; // // if (!node.IsAliasReplaceableExpression()) // { // return false; // } // // var symbol = semanticModel.GetSymbolInfo(node, cancellationToken).Symbol; // // // If the Symbol is a contrcutor get its containing type // if (symbol.IsConstructor()) // { // symbol = symbol.ContainingType; // } // // if (node is QualifiedNameSyntax || node is AliasQualifiedNameSyntax) // { // SyntaxAnnotation aliasAnnotationInfo = null; // // // The following condition checks if the user has used alias in the original code and // // if so the expression is replaced with the Alias // if (node is QualifiedNameSyntax) // { // var qualifiedNameNode = (QualifiedNameSyntax)node; // if (qualifiedNameNode.Right.Identifier.HasAnnotations(AliasAnnotation.Kind)) // { // aliasAnnotationInfo = qualifiedNameNode.Right.Identifier.GetAnnotations(AliasAnnotation.Kind).Single(); // } // } // // if (node is AliasQualifiedNameSyntax) // { // var aliasQualifiedNameNode = (AliasQualifiedNameSyntax)node; // if (aliasQualifiedNameNode.Name.Identifier.HasAnnotations(AliasAnnotation.Kind)) // { // aliasAnnotationInfo = aliasQualifiedNameNode.Name.Identifier.GetAnnotations(AliasAnnotation.Kind).Single(); // } // } // // if (aliasAnnotationInfo != null) // { // var aliasName = AliasAnnotation.GetAliasName(aliasAnnotationInfo); // var aliasIdentifier = SyntaxFactory.IdentifierName(aliasName); // // var aliasTypeInfo = semanticModel.GetSpeculativeAliasInfo(node.SpanStart, aliasIdentifier, SpeculativeBindingOption.BindAsTypeOrNamespace); // // if (aliasTypeInfo != null) // { // aliasReplacement = aliasTypeInfo; // return ValidateAliasForTarget(aliasReplacement, semanticModel, node, symbol); // } // } // } // // if (node.Kind() == SyntaxKind.IdentifierName && // semanticModel.GetAliasInfo((IdentifierNameSyntax)node, cancellationToken) != null) // { // return false; // } // // // an alias can only replace a type or namespace // if (symbol == null || // (symbol.Kind != SymbolKind.Namespace && symbol.Kind != SymbolKind.NamedType)) // { // return false; // } // // if (node is QualifiedNameSyntax) // { // var qualifiedName = (QualifiedNameSyntax)node; // if (!qualifiedName.Right.HasAnnotation(Simplifier.SpecialTypeAnnotation)) // { // var type = semanticModel.GetTypeInfo(node, cancellationToken).Type; // if (type != null) // { // var keywordKind = GetPredefinedKeywordKind(type.SpecialType); // if (keywordKind != SyntaxKind.None) // { // preferAliasToQualifiedName = false; // } // } // } // } // // if (node is AliasQualifiedNameSyntax) // { // var aliasQualifiedNameSyntax = (AliasQualifiedNameSyntax)node; // if (!aliasQualifiedNameSyntax.Name.HasAnnotation(Simplifier.SpecialTypeAnnotation)) // { // var type = semanticModel.GetTypeInfo(node, cancellationToken).Type; // if (type != null) // { // var keywordKind = GetPredefinedKeywordKind(type.SpecialType); // if (keywordKind != SyntaxKind.None) // { // preferAliasToQualifiedName = false; // } // } // } // } // // aliasReplacement = GetAliasForSymbol((INamespaceOrTypeSymbol)symbol, node.GetFirstToken(), semanticModel, cancellationToken); // if (aliasReplacement != null && preferAliasToQualifiedName) // { // return ValidateAliasForTarget(aliasReplacement, semanticModel, node, symbol); // } // // return false; // } // // We must verify that the alias actually binds back to the thing it's aliasing. // It's possible there's another symbol with the same name as the alias that binds // first private static bool ValidateAliasForTarget(IAliasSymbol aliasReplacement, SemanticModel semanticModel, ExpressionSyntax node, ISymbol symbol) { var aliasName = aliasReplacement.Name; var boundSymbols = semanticModel.LookupNamespacesAndTypes(node.SpanStart, name: aliasName); if (boundSymbols.Length == 1) { var boundAlias = boundSymbols[0] as IAliasSymbol; if (boundAlias != null && aliasReplacement.Target.Equals(symbol)) { return true; } } return false; }
private int LookupSymbol(SemanticModel model, int pos, INamespaceOrTypeSymbol container, string symbol) { Console.WriteLine("lookup: " + symbol); //var symbols = model.LookupSymbols(0, container, symbol); var symbols = model.LookupNamespacesAndTypes(pos, container, symbol); foreach (var x in symbols) Console.WriteLine(x.ToDisplayString()); return symbols.Length; }