/// <summary> /// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring. /// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a /// resolve navigator. /// Note: The shared resolver is fully resolved. /// </summary> public static Task<CSharpAstResolver> GetSharedResolver (this Document document) { var parsedDocument = document.ParsedDocument; if (parsedDocument == null) return null; var unit = parsedDocument.GetAst<SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) return null; var resolverAnnotation = document.Annotation<ResolverAnnotation> (); if (resolverAnnotation != null) { if (resolverAnnotation.ParsedFile == parsedFile) return resolverAnnotation.Task; document.RemoveAnnotations<ResolverAnnotation> (); } var resolveTask = Task.Factory.StartNew (delegate { var result = new CSharpAstResolver (document.Compilation, unit, parsedFile); result.ApplyNavigator (new ConstantModeResolveVisitorNavigator (ResolveVisitorNavigationMode.Resolve, null)); return result; }); document.AddAnnotation (new ResolverAnnotation { Task = resolveTask, ParsedFile = parsedFile }); return resolveTask; }
public override IEntity ResolveCref(string cref) { if (cref.Length > 2 && cref[1] == ':') { // resolve ID string return base.ResolveCref(cref); } var documentationReference = new CSharpParser().ParseDocumentationReference(cref); var csharpContext = context as CSharpTypeResolveContext; CSharpResolver resolver; if (csharpContext != null) { resolver = new CSharpResolver(csharpContext); } else { resolver = new CSharpResolver(context.Compilation); } var astResolver = new CSharpAstResolver(resolver, documentationReference); var rr = astResolver.Resolve(documentationReference); MemberResolveResult mrr = rr as MemberResolveResult; if (mrr != null) return mrr.Member; TypeResolveResult trr = rr as TypeResolveResult; if (trr != null) return trr.Type.GetDefinition(); return null; }
public RenameResponse Rename(RenameRequest req) { var project = _solution.ProjectContainingFile(req.FileName); var syntaxTree = project.CreateParser().Parse(req.Buffer, req.FileName); var sourceNode = syntaxTree.GetNodeAt(req.Line, req.Column); if(sourceNode == null) return new RenameResponse(); var originalName = sourceNode.GetText(); IEnumerable<AstNode> nodes = _findUsagesHandler.FindUsageNodes(req).ToArray(); var response = new RenameResponse(); var modfiedFiles = new List<ModifiedFileResponse>(); response.Changes = modfiedFiles; foreach (IGrouping<string, AstNode> groupedNodes in nodes.GroupBy(n => n.GetRegion().FileName.FixPath())) { string fileName = groupedNodes.Key; OmniSharpRefactoringContext context; if (groupedNodes.Key != req.FileName) { var file = _solution.GetFile(fileName); var bufferParser = new BufferParser(_solution); var content = bufferParser.ParsedContent(file.Document.Text, file.FileName); var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile); context = new OmniSharpRefactoringContext(file.Document, resolver); } else { context = OmniSharpRefactoringContext.GetContext(_bufferParser, req); } string modifiedBuffer = null; foreach (var node in groupedNodes.Where(n => n.GetText() == originalName)) { using (var script = new OmniSharpScript(context)) { script.Rename(node, req.RenameTo); modifiedBuffer = script.CurrentDocument.Text; } } if (modifiedBuffer != null) { var modifiedFile = new ModifiedFileResponse { FileName = fileName, Buffer = modifiedBuffer }; modfiedFiles.Add(modifiedFile); response.Changes = modfiedFiles; _bufferParser.ParsedContent(modifiedBuffer, fileName); _solution.GetFile(fileName).Update(modifiedBuffer); } } return response; }
public SemanticErrorsResponse FindSemanticErrors(Request request) { var clientFilename = request.FileName.ApplyPathReplacementsForClient(); var project = _solution.ProjectContainingFile(request.FileName); project.UpdateFile(request.FileName, request.Buffer); var solutionSnapshot = new DefaultSolutionSnapshot(_solution.Projects.Select(i => i.ProjectContent)); SyntaxTree syntaxTree; if(project.CompilerSettings!=null){ syntaxTree = new CSharpParser(project.CompilerSettings).Parse(request.Buffer, request.FileName); }else{ syntaxTree = new CSharpParser().Parse(request.Buffer, request.FileName); } var resolver = new CSharpAstResolver(solutionSnapshot.GetCompilation(project.ProjectContent), syntaxTree); var navigator = new SemanticErrorsNavigator(); resolver.ApplyNavigator(navigator); var errors = navigator.GetErrors() .Where(e => ShouldIncludeIssue(e.Message)) .Select(i => new Error { FileName = clientFilename, Message = i.Message, Line = i.StartLocation.Line, Column = i.EndLocation.Column, EndLine = i.EndLocation.Line, EndColumn = i.EndLocation.Column }); return new SemanticErrorsResponse { Errors = errors, }; }
public static OmniSharpRefactoringContext GetContext(BufferParser bufferParser, Request request) { var q = bufferParser.ParsedContent(request.Buffer, request.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(request.Buffer); var location = new TextLocation(request.Line, request.Column); OmniSharpRefactoringContext refactoringContext; if(request is CodeActionRequest) { var car = request as CodeActionRequest; if(car.SelectionStartColumn.HasValue) { var startLocation = new TextLocation(car.SelectionStartLine.Value, car.SelectionStartColumn.Value); var endLocation = new TextLocation(car.SelectionEndLine.Value, car.SelectionEndColumn.Value); refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location, startLocation, endLocation); } else { refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); } } else { refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); } refactoringContext.Services.AddService (typeof(NamingConventionService), new DefaultNameService ()); return refactoringContext; }
public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node, CancellationToken cancellationToken = default(CancellationToken)) { node = syntaxTree.GetNodeAt(location); if (node == null || node is ArrayInitializerExpression) return null; if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole) { var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile); return r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken); } if (CSharpAstResolver.IsUnresolvableNode(node)) { if (node is Identifier) { node = node.Parent; } else if (node.NodeType == NodeType.Token) { if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) { // There's no other place where one could hover to see the indexer's tooltip, // so we need to resolve it when hovering over the '[' or ']'. // For constructor initializer, the same applies to the 'base'/'this' token. node = node.Parent; } else { return null; } } else { // don't resolve arbitrary nodes - we don't want to show tooltips for everything return null; } } else { // It's a resolvable node. // However, we usually don't want to show the tooltip everywhere // For example, hovering with the mouse over an empty line between two methods causes // node==TypeDeclaration, but we don't want to show any tooltip. if (!node.GetChildByRole(Roles.Identifier).IsNull) { // We'll suppress the tooltip for resolvable nodes if there is an identifier that // could be hovered over instead: return null; } } if (node == null) return null; if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) { node = node.Parent; } InvocationExpression parentInvocation = null; if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) { // we also need to resolve the invocation parentInvocation = node.Parent as InvocationExpression; } // TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile); ResolveResult rr = resolver.Resolve(node, cancellationToken); if (rr is MethodGroupResolveResult && parentInvocation != null) return resolver.Resolve(parentInvocation); else return rr; }
public static void RunTest(CSharpFile file) { CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); var navigator = new ValidatingResolveAllNavigator(file.FileName); resolver.ApplyNavigator(navigator, CancellationToken.None); navigator.Validate(resolver, file.SyntaxTree); }
public static void RunTest(CSharpFile file) { CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile); var navigator = new ValidatingResolveAllNavigator(file.FileName); resolver.ApplyNavigator(navigator, CancellationToken.None); navigator.Validate(file.CompilationUnit); }
static IEnumerable<IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter) { int index = GetArgumentIndex(invoke.Arguments, parameter); if (index < 0) yield break; var targetResult = resolver.Resolve(invoke.Target) as MethodGroupResolveResult; if (targetResult != null) { foreach (var method in targetResult.Methods) { if (index < method.Parameters.Count) { if (method.Parameters [index].IsParams) { var arrayType = method.Parameters [index].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return method.Parameters [index].Type; } } foreach (var extMethods in targetResult.GetExtensionMethods ()) { foreach (var extMethod in extMethods) { if (index + 1 < extMethod.Parameters.Count) { if (extMethod.Parameters [index + 1].IsParams) { var arrayType = extMethod.Parameters [index + 1].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return extMethod.Parameters [index + 1].Type; } } } } }
public ToolTipData (ICSharpCode.NRefactory.CSharp.SyntaxTree unit, ICSharpCode.NRefactory.Semantics.ResolveResult result, ICSharpCode.NRefactory.CSharp.AstNode node, CSharpAstResolver file) { this.Unit = unit; this.Result = result; this.Node = node; this.Resolver = file; }
/// <summary> /// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring. /// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a /// resolve navigator. /// Note: The shared resolver is fully resolved. /// </summary> public static Task<CSharpAstResolver> GetSharedResolver (this Document document) { var parsedDocument = document.ParsedDocument; if (parsedDocument == null || document.IsProjectContextInUpdate || document.Project != null && !(document.Project is DotNetProject)) return null; var unit = parsedDocument.GetAst<SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) return null; var compilation = document.Compilation; var resolverAnnotation = document.Annotation<ResolverAnnotation> (); if (resolverAnnotation != null) { if (resolverAnnotation.ParsedFile == parsedFile) return resolverAnnotation.Task; if (resolverAnnotation.SharedTokenSource != null) resolverAnnotation.SharedTokenSource.Cancel (); document.RemoveAnnotations<ResolverAnnotation> (); } var tokenSource = new CancellationTokenSource (); var token = tokenSource.Token; var resolveTask = Task.Factory.StartNew (delegate { try { using (var timer = ResolveCounter.BeginTiming ()) { var result = new CSharpAstResolver (compilation, unit, parsedFile); result.ApplyNavigator (new ConstantModeResolveVisitorNavigator (ResolveVisitorNavigationMode.Resolve, null), token); return result; } } catch (OperationCanceledException) { return null; } catch (Exception e) { LoggingService.LogError ("Error while creating the resolver.", e); return null; } }, token); var wrapper = resolveTask.ContinueWith (t => { if (t.IsCanceled) return null; if (t.IsFaulted) { var ex = t.Exception.Flatten ().InnerException; if (!(ex is TaskCanceledException)) LoggingService.LogWarning ("Exception while getting shared AST resolver.", ex); return null; } return t.Result; }, TaskContinuationOptions.ExecuteSynchronously); document.AddAnnotation (new ResolverAnnotation { Task = wrapper, ParsedFile = parsedFile, SharedTokenSource = tokenSource }); return wrapper; }
public TestRefactoringContext (IDocument document, TextLocation location, CSharpAstResolver resolver) : base(resolver, CancellationToken.None) { this.doc = document; this.location = location; this.UseExplicitTypes = UseExplict; UseExplict = false; Services.AddService (typeof(NamingConventionService), new TestNameService ()); }
private void InitResolver(SyntaxTree syntaxTree) { if(this.lastFileName != syntaxTree.FileName) { this.lastFileName = syntaxTree.FileName; var unresolvedFile = syntaxTree.ToTypeSystem(); this.resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); } }
private OmniSharpRefactoringContext(IDocument document, CSharpAstResolver resolver, TextLocation location, TextLocation selectionStart, TextLocation selectionEnd) : base(resolver, CancellationToken.None) { _document = document; _location = location; _selectionStart = selectionStart; _selectionEnd = selectionEnd; }
public JavaMethodVisitor(CSharpAstResolver resolver, StreamWriter writer) { this.m_Resolver = resolver; this.m_Writer = writer; this.m_BytecodeWriter = new JavaBytecodeWriter(writer); this.m_Locals.Add("~dummy0", 0); this.m_Locals.Add("~dummy1", 1); }
public static OmniSharpRefactoringContext GetContext(BufferParser bufferParser, Request request) { var q = bufferParser.ParsedContent(request.Buffer, request.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(request.Buffer); var location = new TextLocation(request.Line, request.Column); var refactoringContext = new OmniSharpRefactoringContext(doc, resolver, location); return refactoringContext; }
private OmniSharpRefactoringContext GetRefactoringContext(Request req) { var q = _bufferParser.ParsedContent(req.Buffer, req.FileName); var resolver = new CSharpAstResolver(q.Compilation, q.SyntaxTree, q.UnresolvedFile); var doc = new StringBuilderDocument(req.Buffer); var location = new TextLocation(req.Line, req.Column); var refactoringContext = new OmniSharpRefactoringContext(doc, location, resolver); return refactoringContext; }
public TestRefactoringContext (IDocument document, TextLocation location, CSharpAstResolver resolver) : base(resolver, CancellationToken.None) { this.doc = document; this.location = location; this.UseExplicitTypes = UseExplict; this.FormattingOptions = FormattingOptionsFactory.CreateMono (); UseExplict = false; Services.AddService (typeof(NamingConventionService), new TestNameService ()); Services.AddService (typeof(CodeGenerationService), new DefaultCodeGenerationService ()); }
public SDRefactoringContext(ITextSource textSource, CSharpAstResolver resolver, TextLocation location, int selectionStart, int selectionLength, CancellationToken cancellationToken) : base(resolver, cancellationToken) { this.resolver = resolver; this.textSource = textSource; this.document = textSource as IDocument; this.selectionStart = selectionStart; this.selectionLength = selectionLength; this.location = location; InitializeServices(); }
internal static StubbedRefactoringContext Create(SyntaxTree tree, bool supportsVersion5 = true) { IProjectContent pc = new CSharpProjectContent(); pc = pc.AddAssemblyReferences(CecilLoaderTests.Mscorlib); pc = pc.AddOrUpdateFiles(new[] { tree.ToTypeSystem() }); var compilation = pc.CreateCompilation(); var resolver = new CSharpAstResolver(compilation, tree); return new StubbedRefactoringContext(resolver, supportsVersion5); }
public ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var decompiledParseInfo = parseInfo as ILSpyFullParseInformation; if (decompiledParseInfo == null) throw new ArgumentException("ParseInfo does not have SyntaxTree"); var syntaxTree = decompiledParseInfo.SyntaxTree; var node = syntaxTree.GetNodeAt(location); if (node == null) return null; // null result is allowed; the parser service will substitute a dummy context var resolver = new CSharpAstResolver(compilation, syntaxTree, null); return resolver.GetResolverStateBefore(node); }
public SDRefactoringContext(ITextEditor editor, CSharpAstResolver resolver, TextLocation location, CancellationToken cancellationToken = default(CancellationToken)) : base(resolver, cancellationToken) { this.resolver = resolver; this.editor = editor; this.textSource = editor.Document; this.document = editor.Document; this.selectionStart = editor.SelectionStart; this.selectionLength = editor.SelectionLength; this.location = location; InitializeServices(); }
public FixUsingsResponse FixUsings(Request request) { _fileName = request.FileName; string buffer = RemoveUsings(request.Buffer); buffer = SortUsings(buffer); buffer = AddLinqForQueryIfMissing(buffer); bool ambiguousResultsFound = false; bool usingsAdded = true; while (usingsAdded) { var content = _bufferParser.ParsedContent(buffer, _fileName); var tree = content.SyntaxTree; var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile); var unresolvedNodes = GetAllUnresolvedNodes(tree, resolver).Select(nr => GetNodeToAddUsing(nr)); usingsAdded = false; request.Buffer = buffer; var outerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, request); using (var script = new OmniSharpScript(outerContext, _config)) { foreach (var unresolvedNode in unresolvedNodes) { _logger.Info(unresolvedNode); var requestForNode = CreateRequest(buffer, unresolvedNode); var innerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, requestForNode); var addUsingAction = new AddUsingAction(); var actions = addUsingAction.GetActions(innerContext).Where(a => a.Description.StartsWith("using")).ToArray(); if (actions.Length == 1) { var a = actions[0]; _logger.Info("Adding " + a.Description); a.Run(script); usingsAdded = true; break; } ambiguousResultsFound |= actions.Length > 1; } } buffer = outerContext.Document.Text; } IEnumerable<QuickFix> ambiguous = Enumerable.Empty<QuickFix>(); if (ambiguousResultsFound) { ambiguous = GetAmbiguousNodes(buffer, request.FileName); } return new FixUsingsResponse(buffer, ambiguous); }
/// <summary> /// Finds all references in the given file. /// </summary> /// <param name="searchScopes">The search scopes for which to look.</param> /// <param name="parsedFile">The type system representation of the file being searched.</param> /// <param name="compilationUnit">The compilation unit of the file being searched.</param> /// <param name="callback">Callback used to report the references that were found.</param> /// <param name="cancellationToken">Cancellation token.</param> public void FindReferencesInFile(IList <IFindReferenceSearchScope> searchScopes, CSharpParsedFile parsedFile, CompilationUnit compilationUnit, ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken) { if (searchScopes == null) { throw new ArgumentNullException("searchScopes"); } if (parsedFile == null) { throw new ArgumentNullException("parsedFile"); } if (compilationUnit == null) { throw new ArgumentNullException("compilationUnit"); } if (compilation == null) { throw new ArgumentNullException("compilation"); } if (callback == null) { throw new ArgumentNullException("callback"); } if (searchScopes.Count == 0) { return; } IResolveVisitorNavigator navigator; if (searchScopes.Count == 1) { navigator = searchScopes[0].GetNavigator(compilation, callback); } else { IResolveVisitorNavigator[] navigators = new IResolveVisitorNavigator[searchScopes.Count]; for (int i = 0; i < navigators.Length; i++) { navigators[i] = searchScopes[i].GetNavigator(compilation, callback); } navigator = new CompositeResolveVisitorNavigator(navigators); } cancellationToken.ThrowIfCancellationRequested(); navigator = new DetectSkippableNodesNavigator(navigator, compilationUnit); cancellationToken.ThrowIfCancellationRequested(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile); resolver.ApplyNavigator(navigator, cancellationToken); }
public static SDRefactoringContext Create(ITextEditor editor, CancellationToken cancellationToken) { var parseInfo = SD.ParserService.Parse(editor.FileName, editor.Document, cancellationToken: cancellationToken) as CSharpFullParseInformation; var compilation = SD.ParserService.GetCompilationForFile(editor.FileName); CSharpAstResolver resolver; if (parseInfo != null) { resolver = parseInfo.GetResolver(compilation); } else { // create dummy refactoring context resolver = new CSharpAstResolver(compilation, new SyntaxTree()); } var context = new SDRefactoringContext(editor, resolver, editor.Caret.Location, cancellationToken); return context; }
internal override void NavigatorDone(CSharpAstResolver resolver, CancellationToken cancellationToken) { foreach (var expr in potentialMethodGroupConversions) { var conversion = resolver.GetConversion(expr, cancellationToken); if (conversion.IsMethodGroupConversion && conversion.Method.MemberDefinition == method) { IType targetType = resolver.GetExpectedType(expr, cancellationToken); ResolveResult result = resolver.Resolve(expr, cancellationToken); ReportMatch(expr, new ConversionResolveResult(targetType, result, conversion)); } } base.NavigatorDone(resolver, cancellationToken); }
public static SDRefactoringContext Create(FileName fileName, ITextSource textSource, TextLocation location = default(TextLocation), CancellationToken cancellationToken = default(CancellationToken)) { var parseInfo = SD.ParserService.Parse(fileName, textSource, cancellationToken: cancellationToken) as CSharpFullParseInformation; var compilation = SD.ParserService.GetCompilationForFile(fileName); CSharpAstResolver resolver; if (parseInfo != null) { resolver = parseInfo.GetResolver(compilation); } else { // create dummy refactoring context resolver = new CSharpAstResolver(compilation, new SyntaxTree()); } var context = new SDRefactoringContext(textSource, resolver, location, 0, 0, cancellationToken); return context; }
public CSharpAstResolver GetResolver(ICompilation compilation) { // Cache the resolver within the compilation. // (caching in the parse information could prevent the compilation from being garbage-collected) // Also, don't cache CSharpAstResolvers for every file - doing so would require too much memory, // and we usually only need to access the same file several times. // So we use a static key to get the resolver, and verify that it belongs to this parse information. var resolver = compilation.CacheManager.GetShared(ResolverCacheKey) as CSharpAstResolver; if (resolver == null || resolver.RootNode != syntaxTree || resolver.UnresolvedFile != UnresolvedFile) { resolver = new CSharpAstResolver(compilation, syntaxTree, UnresolvedFile); compilation.CacheManager.SetShared(ResolverCacheKey, resolver); } return resolver; }
public static void RunTestWithoutUnresolvedFile(CSharpFile file) { CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree); var navigator = new ValidatingResolveAllNavigator(file.FileName); resolver.ApplyNavigator(navigator, CancellationToken.None); navigator.Validate(resolver, file.SyntaxTree); CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile); foreach (var node in file.SyntaxTree.DescendantsAndSelf) { var originalResult = originalResolver.Resolve(node); var result = resolver.Resolve(node); if (!RandomizedOrderResolverTest.IsEqualResolveResult(result, originalResult)) { Console.WriteLine("Got different without IUnresolvedFile at " + file.FileName + ":" + node.StartLocation); } } }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); return(Tuple.Create(resolver, FindNode(cu, dollars[0], dollars[1]))); }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { SyntaxTree syntaxTree = new CSharpParser().Parse(code.Replace("$", ""), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem(); project = project.AddOrUpdateFiles(unresolvedFile); compilation = project.CreateCompilation(); CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); return(Tuple.Create(resolver, FindNode(syntaxTree, dollars[0], dollars[1]))); }
static IEnumerable<IType> GetAllValidTypesFromObjectCreation(CSharpAstResolver resolver, ObjectCreateExpression invoke, AstNode parameter) { int index = GetArgumentIndex(invoke.Arguments, parameter); if (index < 0) yield break; var targetResult = resolver.Resolve(invoke.Type); if (targetResult is TypeResolveResult) { var type = ((TypeResolveResult)targetResult).Type; if (type.Kind == TypeKind.Delegate && index == 0) { yield return type; yield break; } foreach (var constructor in type.GetConstructors ()) { if (index < constructor.Parameters.Count) yield return constructor.Parameters [index].Type; } } }
static IEnumerable<IType> GetAllValidTypesFromInvocation(CSharpAstResolver resolver, InvocationExpression invoke, AstNode parameter) { int index = GetArgumentIndex(invoke.Arguments, parameter); if (index < 0) yield break; var targetResult = resolver.Resolve(invoke.Target) as MethodGroupResolveResult; if (targetResult != null) { foreach (var method in targetResult.Methods) { if (index < method.Parameters.Count) { if (method.Parameters [index].IsParams) { var arrayType = method.Parameters [index].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return method.Parameters [index].Type; } } foreach (var extMethods in targetResult.GetExtensionMethods ()) { foreach (var extMethod in extMethods) { IType[] inferredTypes; var m = extMethod; if (CSharpResolver.IsEligibleExtensionMethod(targetResult.TargetType, extMethod, true, out inferredTypes)) { if (inferredTypes != null) m = extMethod.Specialize(new TypeParameterSubstitution(null, inferredTypes)); } int correctedIndex = index + 1; if (correctedIndex < m.Parameters.Count) { if (m.Parameters [correctedIndex].IsParams) { var arrayType = m.Parameters [correctedIndex].Type as ArrayType; if (arrayType != null) yield return arrayType.ElementType; } yield return m.Parameters [correctedIndex].Type; } } } } }
public void Run() { using (new Timer("Finding referenced entities... ")) { foreach (var file in solution.AllFiles) { var navigator = new FindReferencedEntities( delegate (AstNode node, IEntity entity) { if (node == null) throw new ArgumentNullException("node"); if (entity == null) throw new ArgumentNullException("entity"); if (!IgnoreEntity(entity)) { HashSet<AstNode> list; if (!referenceDict.TryGetValue(entity, out list)) { list = new HashSet<AstNode>(); referenceDict.Add(entity, list); } list.Add(node); } } ); var resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile); resolver.ApplyNavigator(navigator); } } Console.WriteLine("For each entity, find all references..."); Stopwatch w = Stopwatch.StartNew(); foreach (var project in solution.Projects) { foreach (var type in project.Compilation.MainAssembly.GetAllTypeDefinitions()) { TestFindReferences(type); foreach (IMember m in type.Members) { TestFindReferences(m); } Console.Write('.'); } } w.Stop(); Console.WriteLine("FindReferencesConsistencyCheck is done ({0}).", w.Elapsed); PrintTimingsPerEntityType(); }
protected Tuple <CSharpAstResolver, AstNode> PrepareResolver(string code) { CompilationUnit cu = new CSharpParser().Parse(new StringReader(code.Replace("$", "")), "code.cs"); TextLocation[] dollars = FindDollarSigns(code).ToArray(); Assert.AreEqual(2, dollars.Length, "Expected 2 dollar signs marking start+end of desired node"); SetUp(); CSharpParsedFile parsedFile = cu.ToTypeSystem(); project = project.UpdateProjectContent(null, parsedFile); compilation = project.CreateCompilation(); FindNodeVisitor fnv = new FindNodeVisitor(dollars[0], dollars[1]); cu.AcceptVisitor(fnv, null); Assert.IsNotNull(fnv.ResultNode, "Did not find DOM node at the specified location"); CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); return(Tuple.Create(resolver, fnv.ResultNode)); }
internal virtual void NavigatorDone(CSharpAstResolver resolver, CancellationToken cancellationToken) { }
public QuickTaskVisitor(ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver resolver, CancellationToken cancellationToken) { this.resolver = resolver; }
public BaseRefactoringContext(ICSharpCode.NRefactory.CSharp.Resolver.CSharpAstResolver resolver, System.Threading.CancellationToken cancellationToken) { this.resolver = resolver; this.cancellationToken = cancellationToken; this.referenceFinder = new LocalReferenceFinder(resolver); }
public static ResolveResult Resolve(Lazy <ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node, CancellationToken cancellationToken = default(CancellationToken)) { node = syntaxTree.GetNodeAt(location); if (node == null || node is ArrayInitializerExpression) { return(null); } if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole) { var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile); return(r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken)); } if (CSharpAstResolver.IsUnresolvableNode(node)) { if (node is Identifier) { node = node.Parent; } else if (node.NodeType == NodeType.Token) { if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer || node.Role == IndexerDeclaration.ThisKeywordRole) { // There's no other place where one could hover to see the indexer's tooltip, // so we need to resolve it when hovering over the '[' or ']'. // For constructor initializer, the same applies to the 'base'/'this' token. node = node.Parent; } else if (node.Parent is BinaryOperatorExpression || node.Parent is UnaryOperatorExpression) { // Resolve user-defined operator node = node.Parent; } else { return(null); } } else { // don't resolve arbitrary nodes - we don't want to show tooltips for everything return(null); } } else { // It's a resolvable node. // However, we usually don't want to show the tooltip everywhere // For example, hovering with the mouse over an empty line between two methods causes // node==TypeDeclaration, but we don't want to show any tooltip. if (!node.GetChildByRole(Roles.Identifier).IsNull) { // We'll suppress the tooltip for resolvable nodes if there is an identifier that // could be hovered over instead: return(null); } } if (node == null) { return(null); } if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) { node = node.Parent; } InvocationExpression parentInvocation = null; if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) { // we also need to resolve the invocation parentInvocation = node.Parent as InvocationExpression; } // TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile); ResolveResult rr = resolver.Resolve(node, cancellationToken); MethodGroupResolveResult mgrr = rr as MethodGroupResolveResult; if (mgrr != null) { // For method groups, resolve the parent invocation instead. if (parentInvocation != null) { return(resolver.Resolve(parentInvocation)); } if (node is Expression) { // If it's not an invocation, try if it's a conversion to a delegate type: Conversion c = resolver.GetConversion((Expression)node, cancellationToken); if (c.IsMethodGroupConversion) { return(new MemberResolveResult(mgrr.TargetResult, c.Method)); } } } return(rr); }
public static ResolveResult Resolve(ICompilation compilation, CSharpParsedFile parsedFile, CompilationUnit cu, TextLocation location, out AstNode node, CancellationToken cancellationToken = default(CancellationToken)) { node = cu.GetNodeAt(location); if (node == null) { return(null); } if (CSharpAstResolver.IsUnresolvableNode(node)) { if (node is Identifier) { node = node.Parent; } else if (node.NodeType == NodeType.Token) { if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) { // There's no other place where one could hover to see the indexer's tooltip, // so we need to resolve it when hovering over the '[' or ']'. // For constructor initializer, the same applies to the 'base'/'this' token. node = node.Parent; } else { return(null); } } else { // don't resolve arbitrary nodes - we don't want to show tooltips for everything return(null); } } else { // It's a resolvable node. // However, we usually don't want to show the tooltip everywhere // For example, hovering with the mouse over an empty line between two methods causes // node==TypeDeclaration, but we don't want to show any tooltip. if (!node.GetChildByRole(AstNode.Roles.Identifier).IsNull) { // We'll suppress the tooltip for resolvable nodes if there is an identifier that // could be hovered over instead: return(null); } } if (node == null) { return(null); } if (node.Parent is ObjectCreateExpression && node.Role == ObjectCreateExpression.Roles.Type) { node = node.Parent; } InvocationExpression parentInvocation = null; if (node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) { // we also need to resolve the invocation parentInvocation = node.Parent as InvocationExpression; } CSharpAstResolver resolver = new CSharpAstResolver(compilation, cu, parsedFile); ResolveResult rr = resolver.Resolve(node, cancellationToken); if (rr is MethodGroupResolveResult && parentInvocation != null) { return(resolver.Resolve(parentInvocation)); } else { return(rr); } }