public ParseInformation Parse(FileName fileName, ITextSource fileContent, bool fullParseInformationRequested, IProject parentProject, CancellationToken cancellationToken) { var csharpProject = parentProject as CSharpProject; CSharpParser parser = new CSharpParser(csharpProject != null ? csharpProject.CompilerSettings : null); SyntaxTree cu = parser.Parse(fileContent, fileName); cu.Freeze(); CSharpUnresolvedFile file = cu.ToTypeSystem(); ParseInformation parseInfo; if (fullParseInformationRequested) parseInfo = new CSharpFullParseInformation(file, fileContent.Version, cu); else parseInfo = new ParseInformation(file, fileContent.Version, fullParseInformationRequested); IDocument document = fileContent as IDocument; AddCommentTags(cu, parseInfo.TagComments, fileContent, parseInfo.FileName, ref document); if (fullParseInformationRequested) { if (document == null) document = new ReadOnlyDocument(fileContent, parseInfo.FileName); ((CSharpFullParseInformation)parseInfo).newFoldings = CreateNewFoldings(cu, document); } return parseInfo; }
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 ParseInformationEventArgs(IProject parentProject, IUnresolvedFile oldUnresolvedFile, ParseInformation newParseInformation) { if (oldUnresolvedFile == null && newParseInformation == null) throw new ArgumentNullException(); if (oldUnresolvedFile != null && newParseInformation != null) { Debug.Assert(FileUtility.IsEqualFileName(oldUnresolvedFile.FileName, newParseInformation.FileName)); } this.parentProject = parentProject; this.oldUnresolvedFile = oldUnresolvedFile; this.newParseInformation = newParseInformation; }
public void UpdateFoldings(ParseInformation parseInfo) { if (!textArea.Document.Version.Equals(parseInfo.ParsedVersion)) { SD.Log.Debug("Folding update ignored; parse information is outdated version"); return; } SD.Log.Debug("Update Foldings"); int firstErrorOffset = -1; IEnumerable<NewFolding> newFoldings = parseInfo.GetFoldings(textArea.Document, out firstErrorOffset); newFoldings = newFoldings.OrderBy(f => f.StartOffset); foldingManager.UpdateFoldings(newFoldings, firstErrorOffset); }
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 ParseInformationEventArgs(IProject parentProject, IUnresolvedFile oldUnresolvedFile, ParseInformation newParseInformation) { if (oldUnresolvedFile == null && newParseInformation == null) { throw new ArgumentNullException(); } if (oldUnresolvedFile != null && newParseInformation != null) { Debug.Assert(FileUtility.IsEqualFileName(oldUnresolvedFile.FileName, newParseInformation.FileName)); } this.parentProject = parentProject; this.oldUnresolvedFile = oldUnresolvedFile; this.newParseInformation = newParseInformation; }
ResolveResult IParser.Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { VB6ParseInformation vpi = (VB6ParseInformation)parseInfo; IUnresolvedMember umember = vpi.UnresolvedFile.GetMember(location); if (umember != null) { IMember member = ConvertToMember(umember); if (member != null) { return new MemberResolveResult(null, member); } } return null; }
public ParserUpdateStepEventArgs(FileName fileName, ITextSource content, ParseInformation parseInformation) { if (fileName == null) { throw new ArgumentNullException("fileName"); } if (content == null) { throw new ArgumentNullException("content"); } if (parseInformation == null) { throw new ArgumentNullException("parseInformation"); } this.fileName = fileName; this.content = content; this.parseInformation = parseInformation; }
public ResolveResult ResolveSnippet(ParseInformation parseInfo, TextLocation location, string codeSnippet, ICompilation compilation, CancellationToken cancellationToken) { var decompiledParseInfo = parseInfo as ILSpyFullParseInformation; if (decompiledParseInfo == null) throw new ArgumentException("ParseInfo does not have SyntaxTree"); CSharpAstResolver contextResolver = new CSharpAstResolver(compilation, decompiledParseInfo.SyntaxTree, null); var node = decompiledParseInfo.SyntaxTree.GetNodeAt(location); CSharpResolver context; if (node != null) context = contextResolver.GetResolverStateAfter(node, cancellationToken); else context = new CSharpResolver(compilation); CSharpParser parser = new CSharpParser(); var expr = parser.ParseExpression(codeSnippet); if (parser.HasErrors) return new ErrorResolveResult(SpecialType.UnknownType, PrintErrorsAsString(parser.Errors), TextLocation.Empty); CSharpAstResolver snippetResolver = new CSharpAstResolver(context, expr); return snippetResolver.Resolve(expr, cancellationToken); }
void AddTagComments(AXmlDocument xmlDocument, ParseInformation parseInfo, ITextSource fileContent) { IDocument document = null; foreach (var tag in TreeTraversal.PreOrder<AXmlObject>(xmlDocument, node => node.Children).OfType<AXmlTag>().Where(t => t.IsComment)) { int matchLength; string commentText = fileContent.GetText(tag.StartOffset, tag.Length); int index = commentText.IndexOfAny(TaskListTokens, 0, out matchLength); if (index > -1) { if (document == null) document = fileContent as IDocument ?? new ReadOnlyDocument(fileContent, parseInfo.FileName); do { TextLocation startLocation = document.GetLocation(tag.StartOffset + index); int startOffset = index + tag.StartOffset; int endOffset = Math.Min(document.GetLineByOffset(startOffset).EndOffset, tag.EndOffset); string content = document.GetText(startOffset, endOffset - startOffset); parseInfo.TagComments.Add(new TagComment(content.Substring(0, matchLength), new DomRegion(parseInfo.FileName, startLocation.Line, startLocation.Column), content.Substring(matchLength))); index = commentText.IndexOfAny(TaskListTokens, endOffset - tag.StartOffset, out matchLength); } while (index > -1); } } }
public ParseInformation Parse(FileName fileName, ITextSource fileContent, bool fullParseInformationRequested, IProject parentProject, CancellationToken cancellationToken) { AXmlParser parser = new AXmlParser(); AXmlDocument document; IncrementalParserState newParserState; if (fileContent.Version is OnDiskTextSourceVersion) { document = parser.Parse(fileContent, cancellationToken); newParserState = null; } else { document = parser.ParseIncremental(parserState, fileContent, out newParserState, cancellationToken); } parserState = newParserState; XamlUnresolvedFile unresolvedFile = XamlUnresolvedFile.Create(fileName, fileContent, document); ParseInformation parseInfo; if (fullParseInformationRequested) parseInfo = new XamlFullParseInformation(unresolvedFile, document, fileContent.CreateSnapshot()); else parseInfo = new ParseInformation(unresolvedFile, fileContent.Version, false); AddTagComments(document, parseInfo, fileContent); return parseInfo; }
public ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { return new XamlAstResolver(compilation, (XamlFullParseInformation)parseInfo) .ResolveAtLocation(location, cancellationToken); }
public void FindLocalReferences(ParseInformation parseInfo, ITextSource fileContent, IVariable variable, ICompilation compilation, Action<SearchResultMatch> callback, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public ProjectEntry(IProject project, IUnresolvedFile unresolvedFile, ParseInformation cachedParseInformation) { this.Project = project; this.UnresolvedFile = unresolvedFile; this.CachedParseInformation = cachedParseInformation; }
public void ParseInformationUpdated(ParseInformation parseInfo) { if (parseInfo != null && CodeEditorOptions.Instance.EnableQuickClassBrowser) { // don't create quickClassBrowser for files that don't have any classes // (but do keep the quickClassBrowser when the last class is removed from a file) if (quickClassBrowser != null || parseInfo.UnresolvedFile.TopLevelTypeDefinitions.Count > 0) { if (quickClassBrowser == null) { quickClassBrowser = new QuickClassBrowser(); quickClassBrowser.JumpAction = (line, col) => ActiveTextEditor.JumpTo(line, col); SetRow(quickClassBrowser, 0); this.Children.Add(quickClassBrowser); } quickClassBrowser.Update(parseInfo.UnresolvedFile); quickClassBrowser.SelectItemAtCaretPosition(this.ActiveTextEditor.TextArea.Caret.Location); } } else { if (quickClassBrowser != null) { this.Children.Remove(quickClassBrowser); quickClassBrowser = null; } } iconBarManager.UpdateClassMemberBookmarks(parseInfo != null ? parseInfo.UnresolvedFile : null, document); primaryTextEditor.UpdateParseInformationForFolding(parseInfo); }
ResolveResult IParser.ResolveSnippet(ParseInformation parseInfo, TextLocation location, string codeSnippet, ICompilation compilation, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public void RegisterUnresolvedFile(IProject project, IUnresolvedFile unresolvedFile) { if (project == null) throw new ArgumentNullException("project"); if (unresolvedFile == null) throw new ArgumentNullException("unresolvedFile"); FreezableHelper.Freeze(unresolvedFile); var newParseInfo = new ParseInformation(unresolvedFile, null, false); lock (this) { int index = FindIndexForProject(project); if (index >= 0) { currentVersion = null; var args = new ParseInformationEventArgs(project, entries[index].UnresolvedFile, newParseInfo); entries[index] = new ProjectEntry(project, unresolvedFile, null); project.OnParseInformationUpdated(args); parserService.RaiseParseInformationUpdated(args); } } }
public ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var csParseInfo = parseInfo as CSharpFullParseInformation; if (csParseInfo == null) throw new ArgumentException("Parse info does not have SyntaxTree"); return ResolveAtLocation.Resolve(compilation, csParseInfo.UnresolvedFile, csParseInfo.SyntaxTree, location, cancellationToken); }
public ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var csParseInfo = parseInfo as CSharpFullParseInformation; if (csParseInfo == null) throw new ArgumentException("Parse info does not have SyntaxTree"); CSharpUnresolvedFile 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 ResolveResult Resolve(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { throw new NotImplementedException(); }
public void UpdateParseInformationForFolding(ParseInformation parseInfo) { if (!CodeEditorOptions.Instance.EnableFolding) { parseInfo = null; } else { if (parseInfo == null || !parseInfo.IsFullParseInformation) parseInfo = SD.ParserService.Parse(this.FileName, this.Document); if (parseInfo != null && !parseInfo.SupportsFolding) parseInfo = null; } IServiceContainer container = this.Adapter.GetService(typeof(IServiceContainer)) as IServiceContainer; ParserFoldingStrategy folding = container.GetService(typeof(ParserFoldingStrategy)) as ParserFoldingStrategy; if (parseInfo == null) { if (folding != null) { folding.Dispose(); container.RemoveService(typeof(ParserFoldingStrategy)); } } else { if (folding == null) { TextArea textArea = this.Adapter.GetService(typeof(TextArea)) as TextArea; folding = new ParserFoldingStrategy(textArea); container.AddService(typeof(ParserFoldingStrategy), folding); } folding.UpdateFoldings(parseInfo); } }
public ParserUpdateStepEventArgs(FileName fileName, ITextSource content, ParseInformation parseInformation) { if (fileName == null) throw new ArgumentNullException("fileName"); if (content == null) throw new ArgumentNullException("content"); if (parseInformation == null) throw new ArgumentNullException("parseInformation"); this.fileName = fileName; this.content = content; this.parseInformation = parseInformation; }
void IParser.FindLocalReferences(ParseInformation parseInfo, ITextSource fileContent, IVariable variable, ICompilation compilation, Action<SearchResultMatch> callback, CancellationToken cancellationToken) { }
public ResolveResult ResolveSnippet(ParseInformation parseInfo, TextLocation location, string codeSnippet, ICompilation compilation, CancellationToken cancellationToken) { return null; }
public ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { var csParseInfo = parseInfo as CSharpFullParseInformation; if (csParseInfo == null) throw new ArgumentException("Parse info does not have SyntaxTree"); CSharpUnresolvedFile 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; var syntaxTree = csParseInfo.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, unresolvedFile); return resolver.GetResolverStateBefore(node); }
public ICodeContext ResolveContext(ParseInformation parseInfo, ICSharpCode.NRefactory.TextLocation location, ICSharpCode.NRefactory.TypeSystem.ICompilation compilation, System.Threading.CancellationToken cancellationToken) { throw new NotImplementedException(); }
public ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { return null; // null result is allowed; the parser service will substitute a dummy context }
public void FindLocalReferences(ParseInformation parseInfo, ITextSource fileContent, IVariable variable, ICompilation compilation, Action<SearchResultMatch> callback, CancellationToken cancellationToken) { var csParseInfo = parseInfo as CSharpFullParseInformation; if (csParseInfo == null) throw new ArgumentException("Parse info does not have SyntaxTree"); ReadOnlyDocument document = null; IHighlighter highlighter = null; new FindReferences().FindLocalReferences( variable, csParseInfo.UnresolvedFile, csParseInfo.SyntaxTree, compilation, delegate (AstNode node, ResolveResult result) { if (document == null) { document = new ReadOnlyDocument(fileContent, parseInfo.FileName); highlighter = SD.EditorControlService.CreateHighlighter(document); highlighter.BeginHighlighting(); } var region = new DomRegion(parseInfo.FileName, node.StartLocation, node.EndLocation); int offset = document.GetOffset(node.StartLocation); int length = document.GetOffset(node.EndLocation) - offset; var builder = SearchResultsPad.CreateInlineBuilder(node.StartLocation, node.EndLocation, document, highlighter); var defaultTextColor = highlighter != null ? highlighter.DefaultTextColor : null; callback(new SearchResultMatch(parseInfo.FileName, node.StartLocation, node.EndLocation, offset, length, builder, defaultTextColor)); }, cancellationToken); if (highlighter != null) { highlighter.Dispose(); } }
void ParserServiceParseInformationUpdated(object sender, ParseInformationEventArgs e) { if (e.FileName != this.FileName) return; this.VerifyAccess(); // When parse information is updated quickly in succession, only do a single update // to the latest version. updateParseInfoTo = e.NewParseInformation; this.Dispatcher.BeginInvoke( DispatcherPriority.Background, new Action( delegate { if (updateParseInfoTo != null) { ParseInformationUpdated(updateParseInfoTo); updateParseInfoTo = null; } })); }
ICodeContext IParser.ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken) { throw new NotImplementedException(); }