void CollectMembers(string code, string memberName, bool includeOverloads = true) { StringBuilder sb = new StringBuilder(); List<int> offsets = new List<int>(); foreach (var ch in code) { if (ch == '$') { offsets.Add(sb.Length); continue; } sb.Append(ch); } var syntaxTree = SyntaxTree.Parse(sb.ToString (), "test.cs"); var unresolvedFile = syntaxTree.ToTypeSystem(); var compilation = TypeSystemHelper.CreateCompilation(unresolvedFile); var symbol = FindReferencesTest.GetSymbol(compilation, memberName); var col = new SymbolCollector(); col.IncludeOverloads = includeOverloads; col.GroupForRenaming = true; var result = col.GetRelatedSymbols (new Lazy<TypeGraph>(() => new TypeGraph (compilation.Assemblies)), symbol); if (offsets.Count != result.Count()) { foreach (var a in result) Console.WriteLine(a); } Assert.AreEqual(offsets.Count, result.Count()); var doc = new ReadOnlyDocument(sb.ToString ()); result .Select(r => doc.GetOffset ((r as IEntity).Region.Begin)) .SequenceEqual(offsets); }
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 ReadOnlyDocumentLine(ReadOnlyDocument doc, int lineNumber) { this.doc = doc; this.lineNumber = lineNumber; this.offset = doc.GetStartOffset(lineNumber); this.endOffset = doc.GetEndOffset(lineNumber); }
public IEnumerable<ICompletionData> CreateProvider(AutoCompleteRequest request) { var editorText = request.Buffer ?? ""; var filename = request.FileName; var partialWord = request.WordToComplete ?? ""; var doc = new ReadOnlyDocument(editorText); var loc = new TextLocation(request.Line, request.Column - partialWord.Length); int cursorPosition = doc.GetOffset(loc); //Ensure cursorPosition only equals 0 when editorText is empty, so line 1,column 1 //completion will work correctly. cursorPosition = Math.Max(cursorPosition, 1); cursorPosition = Math.Min(cursorPosition, editorText.Length); var res = _parser.ParsedContent(editorText, filename); var rctx = res.UnresolvedFile.GetTypeResolveContext(res.Compilation, loc); ICompletionContextProvider contextProvider = new DefaultCompletionContextProvider(doc, res.UnresolvedFile); var engine = new CSharpCompletionEngine(doc, contextProvider, new CompletionDataFactory(partialWord), res.ProjectContent, rctx) { EolMarker = Environment.NewLine }; _logger.Debug("Getting Completion Data"); IEnumerable<ICompletionData> data = engine.GetCompletionData(cursorPosition, true); _logger.Debug("Got Completion Data"); return data.Where(d => d != null && d.DisplayText.IsValidCompletionFor(partialWord)) .FlattenOverloads() .RemoveDupes() .OrderBy(d => d.DisplayText); }
public void SimpleDocument() { string text = "Hello\nWorld!\r\n"; IDocument document = new ReadOnlyDocument(text); Assert.AreEqual(text, document.Text); Assert.AreEqual(3, document.LineCount); Assert.AreEqual(0, document.GetLineByNumber(1).Offset); Assert.AreEqual(5, document.GetLineByNumber(1).EndOffset); Assert.AreEqual(5, document.GetLineByNumber(1).Length); Assert.AreEqual(6, document.GetLineByNumber(1).TotalLength); Assert.AreEqual(1, document.GetLineByNumber(1).DelimiterLength); Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber); Assert.AreEqual(6, document.GetLineByNumber(2).Offset); Assert.AreEqual(12, document.GetLineByNumber(2).EndOffset); Assert.AreEqual(6, document.GetLineByNumber(2).Length); Assert.AreEqual(8, document.GetLineByNumber(2).TotalLength); Assert.AreEqual(2, document.GetLineByNumber(2).DelimiterLength); Assert.AreEqual(2, document.GetLineByNumber(2).LineNumber); Assert.AreEqual(14, document.GetLineByNumber(3).Offset); Assert.AreEqual(14, document.GetLineByNumber(3).EndOffset); Assert.AreEqual(0, document.GetLineByNumber(3).Length); Assert.AreEqual(0, document.GetLineByNumber(3).TotalLength); Assert.AreEqual(0, document.GetLineByNumber(3).DelimiterLength); Assert.AreEqual(3, document.GetLineByNumber(3).LineNumber); }
public static IEnumerable<ICompletionData> DoCodeComplete(string editorText, int offset) // not the best way to put in the whole string every time { var doc = new ReadOnlyDocument(editorText); var location = doc.GetLocation(offset); string parsedText = editorText; // TODO: Why are there different values in test cases? var syntaxTree = new CSharpParser().Parse(parsedText, "program.cs"); syntaxTree.Freeze(); var unresolvedFile = syntaxTree.ToTypeSystem(); var mb = new DefaultCompletionContextProvider(doc, unresolvedFile); IProjectContent pctx = new CSharpProjectContent(); var refs = new List<IUnresolvedAssembly> { mscorlib.Value, systemCore.Value, systemAssembly.Value }; pctx = pctx.AddAssemblyReferences(refs); pctx = pctx.AddOrUpdateFiles(unresolvedFile); var cmp = pctx.CreateCompilation(); var resolver3 = unresolvedFile.GetResolver(cmp, location); var engine = new CSharpCompletionEngine(doc, mb, new TestCompletionDataFactory(resolver3), pctx, resolver3.CurrentTypeResolveContext); engine.EolMarker = Environment.NewLine; engine.FormattingPolicy = FormattingOptionsFactory.CreateMono(); var data = engine.GetCompletionData(offset, controlSpace: false); return data; }
public static void RandomTests(string filePath, int count, CSharpFormattingOptions policy = null, TextEditorOptions options = null) { if (File.Exists(filePath)) { var code = File.ReadAllText(filePath); var document = new ReadOnlyDocument(code); policy = policy ?? FormattingOptionsFactory.CreateMono(); options = options ?? new TextEditorOptions { IndentBlankLines = false }; var engine = new CacheIndentEngine(new CSharpIndentEngine(document, options, policy) { EnableCustomIndentLevels = true }); Random rnd = new Random(); for (int i = 0; i < count; i++) { int offset = rnd.Next(document.TextLength); engine.Update(offset); if (engine.CurrentIndent.Length == 0) continue; } } else { Assert.Fail("File " + filePath + " doesn't exist."); } }
public static CacheIndentEngine CreateEngine(string text, CSharpFormattingOptions formatOptions = null, TextEditorOptions options = null) { if (formatOptions == null) { formatOptions = FormattingOptionsFactory.CreateMono(); formatOptions.AlignToFirstIndexerArgument = formatOptions.AlignToFirstMethodCallArgument = true; } var sb = new StringBuilder(); int offset = 0; for (int i = 0; i < text.Length; i++) { var ch = text [i]; if (ch == '$') { offset = i; continue; } sb.Append(ch); } var document = new ReadOnlyDocument(sb.ToString()); options = options ?? new TextEditorOptions { EolMarker = "\n" }; var result = new CacheIndentEngine(new CSharpIndentEngine(document, options, formatOptions)); result.Update(offset); return result; }
public void SimpleDocument() { string text = "Hello\nWorld!\r\n"; IDocument document = new ReadOnlyDocument(text); Assert.AreEqual(text, document.Text); Assert.AreEqual(3, document.LineCount); Assert.AreEqual(0, document.GetLineByNumber(1).Offset); Assert.AreEqual(5, document.GetLineByNumber(1).EndOffset); Assert.AreEqual(5, document.GetLineByNumber(1).Length); Assert.AreEqual(6, document.GetLineByNumber(1).TotalLength); Assert.AreEqual(1, document.GetLineByNumber(1).DelimiterLength); Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber); Assert.AreEqual(6, document.GetLineByNumber(2).Offset); Assert.AreEqual(12, document.GetLineByNumber(2).EndOffset); Assert.AreEqual(6, document.GetLineByNumber(2).Length); Assert.AreEqual(8, document.GetLineByNumber(2).TotalLength); Assert.AreEqual(2, document.GetLineByNumber(2).DelimiterLength); Assert.AreEqual(2, document.GetLineByNumber(2).LineNumber); Assert.AreEqual(14, document.GetLineByNumber(3).Offset); Assert.AreEqual(14, document.GetLineByNumber(3).EndOffset); Assert.AreEqual(0, document.GetLineByNumber(3).Length); Assert.AreEqual(0, document.GetLineByNumber(3).TotalLength); Assert.AreEqual(0, document.GetLineByNumber(3).DelimiterLength); Assert.AreEqual(3, document.GetLineByNumber(3).LineNumber); }
public ReadOnlyDocumentLine(ReadOnlyDocument doc, int lineNumber) { this.doc = doc; this.lineNumber = lineNumber; this.offset = doc.GetStartOffset(lineNumber); this.endOffset = doc.GetEndOffset(lineNumber); }
/// <inheritdoc/> public IDocument CreateDocumentSnapshot() { if (documentSnapshot == null) { documentSnapshot = new ReadOnlyDocument(this); } return(documentSnapshot); }
/// <summary> /// Converts a readonly TextDocument to a Block and applies the provided highlighting definition. /// </summary> public static Block ConvertTextDocumentToBlock(ReadOnlyDocument document, IHighlightingDefinition highlightingDefinition) { IHighlighter highlighter; if (highlightingDefinition != null) highlighter = new DocumentHighlighter(document, highlightingDefinition); else highlighter = null; return ConvertTextDocumentToBlock(document, highlighter); }
protected static IDocument GetResult(CSharpFormattingOptions policy, string input) { var adapter = new ReadOnlyDocument (input); var visitor = new AstFormattingVisitor (policy, adapter, factory); var compilationUnit = new CSharpParser ().Parse (new StringReader (input), "test.cs"); compilationUnit.AcceptVisitor (visitor, null); return new ReadOnlyDocument (ApplyChanges (input, visitor.Changes)); }
void AssertOutput(AstNode node) { RemoveTokens(node); StringWriter w = new StringWriter(); w.NewLine = "\n"; node.AcceptVisitor(new CSharpOutputVisitor(TokenWriter.CreateWriterThatSetsLocationsInAST(w), FormattingOptionsFactory.CreateSharpDevelop())); var doc = new ReadOnlyDocument(w.ToString()); ConsistencyChecker.CheckMissingTokens(node, "test.cs", doc); ConsistencyChecker.CheckPositionConsistency(node, "test.cs", doc); }
public XamlAstResolver(ICompilation compilation, XamlFullParseInformation parseInfo) { if (compilation == null) throw new ArgumentNullException("compilation"); if (parseInfo == null) throw new ArgumentNullException("parseInfo"); this.compilation = compilation; this.parseInfo = parseInfo; this.textDocument = new ReadOnlyDocument(parseInfo.Text, parseInfo.FileName); }
/// <summary> /// Creates a new DocumentHighlighter instance. /// </summary> public DocumentHighlighter(ReadOnlyDocument document, IHighlightingDefinition definition) { if (document == null) throw new ArgumentNullException("document"); if (definition == null) throw new ArgumentNullException("definition"); this.document = document; this.definition = definition; InvalidateHighlighting(); }
public void ParseAndCheckPositions() { CSharpParser parser = new CSharpParser(); foreach (string fileName in fileNames) { var currentDocument = new ReadOnlyDocument(File.ReadAllText(fileName)); SyntaxTree syntaxTree = parser.Parse(currentDocument, fileName); if (parser.HasErrors) continue; ConsistencyChecker.CheckPositionConsistency(syntaxTree, fileName, currentDocument); ConsistencyChecker.CheckMissingTokens(syntaxTree, fileName, currentDocument); } }
public static ICodeCompletionBinding PrepareDotCompletion(string expressionToComplete, DebuggerCompletionContext context) { var lang = SD.LanguageService.GetLanguageByFileName(context.FileName); if (lang == null) return null; string content = GeneratePartialClassContextStub(context); const string caretPoint = "$__Caret_Point__$;"; int caretOffset = content.IndexOf(caretPoint, StringComparison.Ordinal) + expressionToComplete.Length; SD.Log.DebugFormatted("context used for dot completion: {0}", content.Replace(caretPoint, "$" + expressionToComplete + "|$")); var doc = new ReadOnlyDocument(content.Replace(caretPoint, expressionToComplete)); return lang.CreateCompletionBinding(context.FileName, doc.GetLocation(caretOffset), doc.CreateSnapshot()); }
public void ParseAndCheckPositions() { CSharpParser parser = new CSharpParser(); foreach (string fileName in fileNames) { this.currentDocument = new ReadOnlyDocument(File.ReadAllText(fileName)); CompilationUnit cu = parser.Parse(currentDocument.CreateReader(), fileName); if (parser.HasErrors) continue; this.currentFileName = fileName; CheckPositionConsistency(cu); CheckMissingTokens(cu); } }
public static void Roundtrip(CSharpParser parser, string fileName, string code) { // 1. Parse CompilationUnit cu = parser.Parse(code, fileName); if (parser.HasErrors) throw new InvalidOperationException("There were parse errors."); // 2. Output StringWriter w = new StringWriter(); cu.AcceptVisitor(new CSharpOutputVisitor(w, FormattingOptionsFactory.CreateMono ())); string generatedCode = w.ToString().TrimEnd(); // 3. Compare output with original (modulo whitespaces) int pos2 = 0; for (int pos1 = 0; pos1 < code.Length; pos1++) { if (!char.IsWhiteSpace(code[pos1])) { while (pos2 < generatedCode.Length && char.IsWhiteSpace(generatedCode[pos2])) pos2++; if (pos2 >= generatedCode.Length || code[pos1] != generatedCode[pos2]) { ReadOnlyDocument doc = new ReadOnlyDocument(code); File.WriteAllText(Path.Combine(Program.TempPath, "roundtrip-error.cs"), generatedCode); throw new InvalidOperationException("Mismatch at " + doc.GetLocation(pos1) + " of file " + fileName); } pos2++; } } if (pos2 != generatedCode.Length) throw new InvalidOperationException("Mismatch at end of file " + fileName); // 3b - validate that there are no lone \r if (generatedCode.Replace(w.NewLine, "\n").IndexOf('\r') >= 0) throw new InvalidOperationException(@"Got lone \r in " + fileName); // 4. Parse generated output CompilationUnit generatedCU; try { generatedCU = parser.Parse(generatedCode, fileName); } catch { File.WriteAllText(Path.Combine(Program.TempPath, "roundtrip-error.cs"), generatedCode, Encoding.Unicode); throw; } if (parser.HasErrors) { File.WriteAllText(Path.Combine(Program.TempPath, "roundtrip-error.cs"), generatedCode); throw new InvalidOperationException("There were parse errors in the roundtripped " + fileName); } // 5. Compare AST1 with AST2 if (!cu.IsMatch(generatedCU)) throw new InvalidOperationException("AST match failed for " + fileName + "."); }
public static XamlUnresolvedFile Create(FileName fileName, ITextSource fileContent, AXmlDocument document) { XamlUnresolvedFile file = new XamlUnresolvedFile(fileName); ReadOnlyDocument textDocument = new ReadOnlyDocument(fileContent, fileName); file.errors.AddRange(document.SyntaxErrors.Select(err => new Error(ErrorType.Error, err.Description, textDocument.GetLocation(err.StartOffset)))); var visitor = new XamlDocumentVisitor(file, textDocument); visitor.VisitDocument(document); if (visitor.TypeDefinition != null) file.topLevel = new[] { visitor.TypeDefinition }; else file.topLevel = new IUnresolvedTypeDefinition[0]; return file; }
public void EmptyReadOnlyDocument() { IDocument document = new ReadOnlyDocument(string.Empty); Assert.AreEqual(string.Empty, document.Text); Assert.AreEqual(0, document.TextLength); Assert.AreEqual(1, document.LineCount); Assert.AreEqual(0, document.GetOffset(1, 1)); Assert.AreEqual(new TextLocation(1, 1), document.GetLocation(0)); Assert.AreEqual(0, document.GetLineByNumber(1).Offset); Assert.AreEqual(0, document.GetLineByNumber(1).EndOffset); Assert.AreEqual(0, document.GetLineByNumber(1).Length); Assert.AreEqual(0, document.GetLineByNumber(1).TotalLength); Assert.AreEqual(0, document.GetLineByNumber(1).DelimiterLength); Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber); }
public void EmptyReadOnlyDocument() { IDocument document = new ReadOnlyDocument(string.Empty); Assert.AreEqual(string.Empty, document.Text); Assert.AreEqual(0, document.TextLength); Assert.AreEqual(1, document.LineCount); Assert.AreEqual(0, document.GetOffset(1, 1)); Assert.AreEqual(new TextLocation(1, 1), document.GetLocation(0)); Assert.AreEqual(0, document.GetLineByNumber(1).Offset); Assert.AreEqual(0, document.GetLineByNumber(1).EndOffset); Assert.AreEqual(0, document.GetLineByNumber(1).Length); Assert.AreEqual(0, document.GetLineByNumber(1).TotalLength); Assert.AreEqual(0, document.GetLineByNumber(1).DelimiterLength); Assert.AreEqual(1, document.GetLineByNumber(1).LineNumber); }
public static void CheckMissingTokens(AstNode node, string currentFileName, IDocument currentDocument = null) { if (currentDocument == null) currentDocument = new ReadOnlyDocument(File.ReadAllText(currentFileName)); if (IsLeafNode(node)) { Assert.IsNull(node.FirstChild, "Token nodes should not have children"); } else { var prevNodeEnd = node.StartLocation; var prevNode = node; for (AstNode child = node.FirstChild; child != null; child = child.NextSibling) { CheckWhitespace(prevNode, prevNodeEnd, child, child.StartLocation, currentFileName, currentDocument); CheckMissingTokens(child, currentFileName, currentDocument); prevNode = child; prevNodeEnd = child.EndLocation; } CheckWhitespace(prevNode, prevNodeEnd, node, node.EndLocation, currentFileName, currentDocument); } }
public override void FixtureSetUp() { base.FixtureSetUp(); SD.Services.AddService(typeof(IWorkbench), MockRepository.GenerateStub<IWorkbench>()); // Set up SearchOptions required by the BruteForceSearchStrategy. SearchOptions.CurrentFindPattern = "foo"; SearchOptions.MatchCase = false; SearchOptions.MatchWholeWord = false; // Create the document to be searched. var doc = new ReadOnlyDocument("foo"); var location = MockRepository.GenerateStub<SearchLocation>(SearchOptions.SearchTarget, SearchOptions.LookIn, SearchOptions.LookInFiletypes, SearchOptions.IncludeSubdirectories, null); location.Stub(l => l.GenerateFileList()).Return(new[] { new FileName(@"C:\Temp\test.txt") }); // Search the document. var strategy = SearchStrategyFactory.Create(SearchOptions.FindPattern, !SearchOptions.MatchCase, SearchOptions.MatchWholeWord, SearchOptions.SearchMode); result = SearchManager.FindNext(strategy, location); }
public static IDocumentIndentEngine CreateEngine(string text, CSharpFormattingOptions formatOptions = null, IEnumerable<string> symbols = null) { var policy = formatOptions; if ( policy == null) { policy = FormattingOptionsFactory.CreateMono(); policy.IndentPreprocessorDirectives = false; policy.AlignToFirstMethodCallArgument = policy.AlignToFirstIndexerArgument = true; } var sb = new StringBuilder(); int offset = 0; for (int i = 0; i < text.Length; i++) { var ch = text[i]; if (ch == '$') { offset = i; continue; } sb.Append(ch); } var document = new ReadOnlyDocument(sb.ToString()); var options = new TextEditorOptions(); var csi = new CSharpIndentEngine(document, options, policy) { EnableCustomIndentLevels = true }; if (symbols != null) { foreach (var sym in symbols) { csi.DefineSymbol(sym); } } var result = new CacheIndentEngine(csi); result.Update(offset); return result; }
public static void CheckPositionConsistency (AstNode node, string currentFileName, IDocument currentDocument = null) { if (currentDocument == null) currentDocument = new ReadOnlyDocument(File.ReadAllText(currentFileName)); string comment = "(" + node.GetType ().Name + " at " + node.StartLocation + " in " + currentFileName + ")"; var pred = node.StartLocation <= node.EndLocation; if (!pred) PrintNode (node); Assert.IsTrue(pred, "StartLocation must be before EndLocation " + comment); var prevNodeEnd = node.StartLocation; var prevNode = node; for (AstNode child = node.FirstChild; child != null; child = child.NextSibling) { bool assertion = child.StartLocation >= prevNodeEnd; if (!assertion) { PrintNode (prevNode); PrintNode (node); } Assert.IsTrue(assertion, currentFileName + ": Child " + child.GetType () +" (" + child.StartLocation + ")" +" must start after previous sibling " + prevNode.GetType () + "(" + prevNode.StartLocation + ")"); CheckPositionConsistency(child, currentFileName, currentDocument); prevNodeEnd = child.EndLocation; prevNode = child; } Assert.IsTrue(prevNodeEnd <= node.EndLocation, "Last child must end before parent node ends " + comment); }
static int GetIndex(string text) { var editorText = new StringBuilder(); int trigger = 0, end = 0; for (int i = 0; i < text.Length; i++) { if (text[i] == '@') { trigger = editorText.Length; continue; } if (text[i] == '$') { end = editorText.Length; continue; } editorText.Append(text [i]); } var doc = new ReadOnlyDocument(editorText.ToString ()); var pctx = new CSharpProjectContent(); var rctx = new CSharpTypeResolveContext(pctx.CreateCompilation().MainAssembly); var ctxProvider = new DefaultCompletionContextProvider(doc, new CSharpUnresolvedFile()); var engine = new CSharpParameterCompletionEngine(doc, ctxProvider, new ParameterCompletionTests.TestFactory(pctx), pctx, rctx); return engine.GetCurrentParameterIndex(trigger, end); }
public static void ReadAndTest(string filePath, CSharpFormattingOptions policy = null, TextEditorOptions options = null) { if (File.Exists(filePath)) { filePath = Path.GetFullPath(filePath); var code = File.ReadAllText(filePath); var document = new ReadOnlyDocument(code); if (policy == null) { policy = FormattingOptionsFactory.CreateMono(); policy.AlignToFirstIndexerArgument = policy.AlignToFirstMethodCallArgument = true; } options = options ?? new TextEditorOptions { IndentBlankLines = false }; var engine = new CacheIndentEngine(new CSharpIndentEngine(document, options, policy) { EnableCustomIndentLevels = true }); int errors = 0; foreach (var ch in code) { if (options.EolMarker[0] == ch) { if (!(engine.LineBeganInsideMultiLineComment || engine.LineBeganInsideVerbatimString)) { if (engine.CurrentIndent.Length > 0) { if (engine.NeedsReindent) { errors++; Console.WriteLine(string.Format("Indent: {2}, Current indent: {3} in {0}:{1}", filePath, engine.Location.Line, engine.ThisLineIndent.Length, engine.CurrentIndent.Length)); } } } } engine.Push(ch); } Assert.AreEqual(0, errors); } else { Assert.Fail("File " + filePath + " doesn't exist."); } }
static CompletionDataList CreateProvider (string text, CompilationUnit compilationUnit, CSharpCompletionEngine engine, ReadOnlyDocument doc, TextLocation loc) { var cursorPosition = doc.GetOffset (loc); var data = engine.GetCompletionData (cursorPosition, true); return new CompletionDataList () { Data = data, AutoCompleteEmptyMatch = engine.AutoCompleteEmptyMatch, AutoSelect = engine.AutoSelect, DefaultCompletionString = engine.DefaultCompletionString }; }
Tuple<ReadOnlyDocument, CSharpCompletionEngine> GetContent (string text, CompilationUnit compilationUnit) { var doc = new ReadOnlyDocument (text); IProjectContent pctx = new CSharpProjectContent (); pctx = pctx.AddAssemblyReferences (new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var parsedFile = compilationUnit.ToTypeSystem (); pctx = pctx.UpdateProjectContent (null, parsedFile); var cmp = pctx.CreateCompilation (); var engine = new CSharpCompletionEngine (doc, new TestFactory (), pctx, new CSharpTypeResolveContext (cmp.MainAssembly), compilationUnit, parsedFile); engine.EolMarker = Environment.NewLine; engine.FormattingPolicy = FormattingOptionsFactory.CreateMono (); return Tuple.Create (doc, engine); }
static CompletionDataList CreateProvider (string text, bool isCtrlSpace) { string parsedText; string editorText; int cursorPosition = text.IndexOf ('$'); int endPos = text.IndexOf ('$', cursorPosition + 1); if (endPos == -1) { parsedText = editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1); } else { parsedText = text.Substring (0, cursorPosition) + new string (' ', endPos - cursorPosition) + text.Substring (endPos + 1); editorText = text.Substring (0, cursorPosition) + text.Substring (cursorPosition + 1, endPos - cursorPosition - 1) + text.Substring (endPos + 1); cursorPosition = endPos - 1; } var doc = new ReadOnlyDocument (editorText); IProjectContent pctx = new CSharpProjectContent (); pctx = pctx.AddAssemblyReferences (new [] { CecilLoaderTests.Mscorlib, CecilLoaderTests.SystemCore }); var compilationUnit = new CSharpParser ().Parse (parsedText, "program.cs"); compilationUnit.Freeze (); var parsedFile = compilationUnit.ToTypeSystem (); pctx = pctx.UpdateProjectContent (null, parsedFile); var cmp = pctx.CreateCompilation (); var loc = doc.GetLocation (cursorPosition); var rctx = new CSharpTypeResolveContext (cmp.MainAssembly); rctx = rctx.WithUsingScope (parsedFile.GetUsingScope (loc).Resolve (cmp)); var curDef = parsedFile.GetInnermostTypeDefinition (loc); if (curDef != null) { var resolvedDef = curDef.Resolve (rctx).GetDefinition (); rctx = rctx.WithCurrentTypeDefinition (resolvedDef); var curMember = resolvedDef.Members.FirstOrDefault (m => m.Region.Begin <= loc && loc < m.BodyRegion.End); if (curMember != null) rctx = rctx.WithCurrentMember (curMember); } var engine = new CSharpCompletionEngine (doc, new TestFactory (), pctx, rctx, compilationUnit, parsedFile); engine.EolMarker = Environment.NewLine; engine.FormattingPolicy = FormattingOptionsFactory.CreateMono (); var data = engine.GetCompletionData (cursorPosition, isCtrlSpace); return new CompletionDataList () { Data = data, AutoCompleteEmptyMatch = engine.AutoCompleteEmptyMatch, AutoSelect = engine.AutoSelect, DefaultCompletionString = engine.DefaultCompletionString }; }
void AddCommentTags(SyntaxTree cu, IList<TagComment> tagComments, ITextSource fileContent, FileName fileName, ref IDocument document) { foreach (var comment in cu.Descendants.OfType<Comment>()) { if (comment.CommentType == CommentType.InactiveCode) continue; string match; if (comment.Content.ContainsAny(TaskListTokens, 0, out match)) { if (document == null) document = new ReadOnlyDocument(fileContent, fileName); int commentSignLength = comment.CommentType == CommentType.Documentation || comment.CommentType == CommentType.MultiLineDocumentation ? 3 : 2; int commentEndSignLength = comment.CommentType == CommentType.MultiLine || comment.CommentType == CommentType.MultiLineDocumentation ? 2 : 0; int commentStartOffset = document.GetOffset(comment.StartLocation) + commentSignLength; int commentEndOffset = document.GetOffset(comment.EndLocation) - commentEndSignLength; int endOffset; int searchOffset = 0; do { int start = commentStartOffset + searchOffset; int absoluteOffset = document.IndexOf(match, start, document.TextLength - start, StringComparison.Ordinal); var startLocation = document.GetLocation(absoluteOffset); endOffset = Math.Min(document.GetLineByNumber(startLocation.Line).EndOffset, commentEndOffset); string content = document.GetText(absoluteOffset, endOffset - absoluteOffset); if (content.Length < match.Length) { // HACK: workaround parser bug with multi-line documentation comments break; } tagComments.Add(new TagComment(content.Substring(0, match.Length), new DomRegion(cu.FileName, startLocation.Line, startLocation.Column), content.Substring(match.Length))); searchOffset = endOffset - commentStartOffset; } while (comment.Content.ContainsAny(TaskListTokens, searchOffset, out match)); } } }
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(); } }