public static bool ResolveAt(Document doc, out ResolveResult resolveResult, out AstNode node, CancellationToken token = default(CancellationToken)) { var parsedDocument = doc.ParsedDocument; resolveResult = null; node = null; if (parsedDocument == null) { return(false); } var unit = parsedDocument.GetAst <SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) { return(false); } try { var location = RefactoringService.GetCorrectResolveLocation(doc, doc.Editor.Caret.Location); resolveResult = ResolveAtLocation.Resolve(doc.Compilation, parsedFile, unit, location, out node, token); if (resolveResult == null || node is Statement) { return(false); } } catch (OperationCanceledException) { return(false); } catch (Exception e) { Console.WriteLine("Got resolver exception:" + e); return(false); } return(true); }
public QuickFixResponse FindDerivedMembersAsQuickFixes (GotoImplementationRequest request) { var res = _bufferParser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); ResolveResult resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); var rctx = new CSharpTypeResolveContext(res.Compilation.MainAssembly); var usingScope = res.UnresolvedFile.GetUsingScope(loc).Resolve(res.Compilation); rctx = rctx.WithUsingScope(usingScope); if (resolveResult is TypeResolveResult) { return(GetTypeResponse(rctx, resolveResult.Type.GetDefinition())); } if (resolveResult is MemberResolveResult) { return(GetMemberResponse(rctx, resolveResult as MemberResolveResult)); } return(new QuickFixResponse()); }
public static bool TryResolveAt(this Document doc, DocumentLocation loc, out ResolveResult result, out AstNode node) { if (doc == null) { throw new ArgumentNullException("doc"); } result = null; node = null; var parsedDocument = doc.ParsedDocument; if (parsedDocument == null) { return(false); } var unit = parsedDocument.GetAst <CompilationUnit> (); var parsedFile = parsedDocument.ParsedFile as CSharpParsedFile; if (unit == null || parsedFile == null) { return(false); } try { result = ResolveAtLocation.Resolve(() => doc.Compilation, parsedFile, unit, loc, out node); if (result == null || node is Statement) { return(false); } } catch (Exception e) { Console.WriteLine("Got resolver exception:" + e); return(false); } return(true); }
void ResolveButtonClick(object sender, EventArgs e) { IProjectContent project = new CSharpProjectContent(); var unresolvedFile = syntaxTree.ToTypeSystem(); project = project.AddOrUpdateFiles(unresolvedFile); //project = project.AddAssemblyReferences(builtInLibs.Value); ICompilation compilation = project.CreateCompilation(); ResolveResult result; if (csharpTreeView.SelectedNode != null) { var selectedNode = (AstNode)csharpTreeView.SelectedNode.Tag; CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile); result = resolver.Resolve(selectedNode); // CSharpAstResolver.Resolve() never returns null } else { TextLocation location = GetTextLocation(csharpCodeTextBox, csharpCodeTextBox.SelectionStart); result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location); if (result == null) { MessageBox.Show("Could not find a resolvable node at the caret location."); return; } } using (var dlg = new SemanticTreeDialog(result)) dlg.ShowDialog(); }
public Common.DomRegion ResolveTypeByName(string typeName, string typeMemberName) { if (Project == null) { return(Common.DomRegion.Empty); } var code = $"class dummy11111 {{ System.Type t = typeof({typeName}); }}"; var location = new ReadOnlyDocument(code).GetLocation(code.Length - 6); var syntaxTree = new CSharpParser().Parse(code, "dummy11111.cs"); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); Project = Project.AddOrUpdateFiles(unresolvedFile); var compilation = Project.CreateCompilation(); var result = ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location); var type = (result as TypeResolveResult).Type as DefaultResolvedTypeDefinition; if (type != null) { var asm = type.ParentAssembly; if (asm.UnresolvedAssembly is IUnresolvedAssembly) //referenced assembly { FileLocation document = new Reflector().ReconstructToFile(asm, type, memberName: typeMemberName); return(document.ToDomRegion().ToCommon()); } } return(Common.DomRegion.Empty); }
public static bool ResolveAt(Document doc, out ResolveResult resolveResult, out AstNode node) { var parsedDocument = doc.ParsedDocument; resolveResult = null; node = null; if (parsedDocument == null) { return(false); } var unit = parsedDocument.GetAst <CompilationUnit> (); var parsedFile = parsedDocument.ParsedFile as CSharpParsedFile; if (unit == null || parsedFile == null) { return(false); } try { resolveResult = ResolveAtLocation.Resolve(doc.Compilation, parsedFile, unit, doc.Editor.Caret.Location, out node); if (resolveResult == null || node is Statement) { return(false); } } catch (Exception e) { Console.WriteLine("Got resolver exception:" + e); return(false); } return(true); }
static ResolveResult GetHeuristicResult(Document doc, DocumentLocation location, ref AstNode node) { var editor = doc.Editor; if (editor == null || editor.Caret == null) { return(null); } int offset = editor.Caret.Offset; bool wasLetter = false, wasWhitespaceAfterLetter = false; while (offset < editor.Length) { char ch = editor.GetCharAt(offset); bool isLetter = char.IsLetterOrDigit(ch) || ch == '_'; bool isWhiteSpace = char.IsWhiteSpace(ch); bool isValidPunc = ch == '.' || ch == '<' || ch == '>'; if (!(wasLetter && wasWhitespaceAfterLetter) && (isLetter || isWhiteSpace || isValidPunc)) { if (isValidPunc) { wasWhitespaceAfterLetter = false; wasLetter = false; } offset++; } else { offset--; while (offset > 1) { ch = editor.GetCharAt(offset - 1); if (!(ch == '.' || char.IsWhiteSpace(ch))) { break; } offset--; } break; } wasLetter |= isLetter; if (wasLetter) { wasWhitespaceAfterLetter |= isWhiteSpace; } } var unit = SyntaxTree.Parse(CreateStub(doc, offset), doc.FileName); return(ResolveAtLocation.Resolve( doc.Compilation, doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile, unit, location, out node)); }
public ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var decompiledParseInfo = parseInfo as ILSpyFullParseInformation; if (decompiledParseInfo == null) { throw new ArgumentException("ParseInfo does not have SyntaxTree"); } return(ResolveAtLocation.Resolve(compilation, null, decompiledParseInfo.SyntaxTree, location, cancellationToken)); }
public TypeLookupResponse GetTypeLookupResponse(TypeLookupRequest request) { var res = _bufferParser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); var resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); var response = new TypeLookupResponse(); var ambience = new CSharpAmbience() { ConversionFlags = AmbienceFlags, }; if (resolveResult == null || resolveResult is NamespaceResolveResult) { response.Type = ""; } else if (resolveResult != null) { response.Type = resolveResult.Type.ToString(); if (resolveResult is CSharpInvocationResolveResult) { var result = resolveResult as CSharpInvocationResolveResult; response.Type = ambience.ConvertEntity(result.Member); } else if (resolveResult is LocalResolveResult) { var result = resolveResult as LocalResolveResult; response.Type = ambience.ConvertVariable(result.Variable); } else if (resolveResult is MemberResolveResult) { var result = resolveResult as MemberResolveResult; response.Type = ambience.ConvertEntity(result.Member); } else if (resolveResult is TypeResolveResult) { ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedTypeNames; response.Type = ambience.ConvertType(resolveResult.Type); } if (resolveResult.Type is UnknownType) { response.Type = "Unknown Type: " + resolveResult.Type.Name; } if (resolveResult.Type == SpecialType.UnknownType) { response.Type = "Unknown Type"; } } return(response); }
public ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var csParseInfo = parseInfo as AlFullParseInformation; if (csParseInfo == null) throw new ArgumentException("Parse info does not have SyntaxTree"); AlUnresolvedFile unresolvedFile = csParseInfo.UnresolvedFile; var projectContents = compilation.Assemblies.Select(asm => asm.UnresolvedAssembly).OfType<IProjectContent>().ToList(); if (projectContents.All(pc => pc.GetFile(unresolvedFile.FileName) != unresolvedFile)) unresolvedFile = null; return ResolveAtLocation.Resolve(compilation, unresolvedFile, csParseInfo.SyntaxTree, location, cancellationToken); }
public GotoDefinitionResponse GetGotoDefinitionResponse(GotoDefinitionRequest request) { var res = _bufferParser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); ResolveResult resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); var response = new GotoDefinitionResponse(); if (resolveResult != null) { var region = resolveResult.GetDefinitionRegion(); response.FileName = region.FileName == null ? null : region.FileName.ApplyPathReplacementsForClient(); response.Line = region.BeginLine; response.Column = region.BeginColumn; } return(response); }
ResolveResult ResolveFromPosition(string editorText, int offset, string fileName) { if (Project == null) { return(null); } var location = new ReadOnlyDocument(editorText).GetLocation(offset); var syntaxTree = new CSharpParser().Parse(editorText, fileName); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); Project = Project.AddOrUpdateFiles(unresolvedFile); var compilation = Project.CreateCompilation(); return(ResolveAtLocation.Resolve(compilation, unresolvedFile, syntaxTree, location)); }
static bool TryResolveAt(Document doc, DocumentLocation loc, out ResolveResult result, out AstNode node) { if (doc == null) { throw new ArgumentNullException("doc"); } result = null; node = null; var parsedDocument = doc.ParsedDocument; if (parsedDocument == null) { return(false); } var unit = parsedDocument.GetAst <SyntaxTree> (); var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile; if (unit == null || parsedFile == null) { return(false); } try { result = ResolveAtLocation.Resolve(new Lazy <ICompilation> (() => doc.Compilation), parsedFile, unit, loc, out node); if (result == null || node is Statement) { return(false); } } catch { return(false); } return(true); }
public TypeLookupResponse GetTypeLookupResponse(TypeLookupRequest request) { var res = _bufferParser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); var resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); var response = new TypeLookupResponse(); var ambience = new CSharpAmbience() { ConversionFlags = AmbienceFlags, }; if (resolveResult == null || resolveResult is NamespaceResolveResult) { response.Type = ""; } else { response.Type = resolveResult.Type.ToString(); IEntity entity = null; if (resolveResult is CSharpInvocationResolveResult) { var result = resolveResult as CSharpInvocationResolveResult; entity = result.Member; response.Type = ambience.ConvertSymbol(result.Member); } else if (resolveResult is LocalResolveResult) { var result = resolveResult as LocalResolveResult; response.Type = ambience.ConvertVariable(result.Variable); } else if (resolveResult is MemberResolveResult) { var result = resolveResult as MemberResolveResult; entity = result.Member; response.Type = ambience.ConvertSymbol(result.Member); } else if (resolveResult is TypeResolveResult) { ambience.ConversionFlags |= ConversionFlags.UseFullyQualifiedTypeNames; response.Type = ambience.ConvertType(resolveResult.Type); } if (resolveResult.Type is UnknownType) { response.Type = "Unknown Type: " + resolveResult.Type.Name; } if (resolveResult.Type == SpecialType.UnknownType) { response.Type = "Unknown Type"; } if (request.IncludeDocumentation && entity != null) { var project = _solution.ProjectContainingFile(request.FileName); response.Documentation = new DocumentationFetcher().GetDocumentation(project, entity, _config); } } return(response); }
public IEnumerable <AstNode> FindUsageNodes(Request request) { var res = _parser.ParsedContent(request.Buffer, request.FileName); var loc = new TextLocation(request.Line, request.Column); _result = new ConcurrentBag <AstNode>(); var findReferences = new FindReferences { FindCallsThroughInterface = true, FindCallsThroughVirtualBaseMethod = true, FindTypeReferencesEvenIfAliased = true, }; ResolveResult resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc); if (resolveResult is LocalResolveResult) { var variable = (resolveResult as LocalResolveResult).Variable; findReferences.FindLocalReferences(variable, res.UnresolvedFile, res.SyntaxTree, res.Compilation, (node, rr) => _result.Add(node.GetDefinition()), CancellationToken.None); } else { IEntity entity = null; IEnumerable <IList <IFindReferenceSearchScope> > searchScopes = null; if (resolveResult is TypeResolveResult) { var type = (resolveResult as TypeResolveResult).Type; entity = type.GetDefinition(); ProcessTypeResults(type); searchScopes = new[] { findReferences.GetSearchScopes(entity) }; } if (resolveResult is MemberResolveResult) { entity = (resolveResult as MemberResolveResult).Member; if (entity.EntityType == EntityType.Constructor) { // process type instead var type = entity.DeclaringType; entity = entity.DeclaringTypeDefinition; ProcessTypeResults(type); searchScopes = new[] { findReferences.GetSearchScopes(entity) }; } else { ProcessMemberResults(resolveResult); var members = MemberCollector.CollectMembers(_solution, (resolveResult as MemberResolveResult).Member); searchScopes = members.Select(findReferences.GetSearchScopes); } } if (entity == null) { return(_result); } var interesting = new List <CSharpUnresolvedFile>(); foreach (var project in _solution.Projects) { var pctx = project.ProjectContent.CreateCompilation(); interesting = (from file in project.Files select(file.ParsedFile as CSharpUnresolvedFile)).ToList(); foreach (var file in interesting) { string text = _solution.GetFile(file.FileName).Content.Text; var unit = new CSharpParser().Parse(text, file.FileName); foreach (var scope in searchScopes) { findReferences.FindReferencesInFile(scope, file, unit, pctx, (node, rr) => _result.Add(node.GetIdentifier()), CancellationToken.None); } } } } return(_result); }