public IndentationTrackerWrapper (Mono.TextEditor.TextEditorData textEditorData, IReadonlyTextDocument document, MonoDevelop.Ide.Editor.Extension.IndentationTracker indentationTracker) { if (textEditorData == null) throw new System.ArgumentNullException ("textEditorData"); if (document == null) throw new System.ArgumentNullException ("document"); if (indentationTracker == null) throw new System.ArgumentNullException ("indentationTracker"); this.document = document; this.indentationTracker = indentationTracker; }
public override async Task<BraceMatchingResult?> GetMatchingBracesAsync (IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken = default(CancellationToken)) { if (context.ParsedDocument == null) return await fallback.GetMatchingBracesAsync (editor, context, offset, cancellationToken); var analysisDocument = context.AnalysisDocument; if (analysisDocument == null) return null; var partialDoc = await CSharpCompletionTextEditorExtension.WithFrozenPartialSemanticsAsync (analysisDocument, cancellationToken).ConfigureAwait (false); var root = await partialDoc.GetSyntaxRootAsync (cancellationToken).ConfigureAwait (false); if (offset < 0 || root.Span.End <= offset) return null; var token = root.FindToken (offset); var tokenSpan = token.Span; if (offset < tokenSpan.Start || offset >= tokenSpan.End) return null; for (int i = 0; i < tokenPairs.Length / 2; i++) { var open = tokenPairs [i * 2]; var close = tokenPairs [i * 2 + 1]; SyntaxToken match; if (token.IsKind (open)) { if (TryFindMatchingToken (token, out match, open, close)) { return new BraceMatchingResult (new TextSegment (tokenSpan.Start, tokenSpan.Length), new TextSegment (match.Span.Start, match.Span.Length), true); } } else if (token.IsKind (close)) { if (TryFindMatchingToken (token, out match, open, close)) { return new BraceMatchingResult (new TextSegment (match.Span.Start, match.Span.Length), new TextSegment (tokenSpan.Start, tokenSpan.Length), false); } } } if (token.IsKind (SyntaxKind.StringLiteralToken) && token.ToString().EndsWith ("\"", StringComparison.Ordinal)) { if (token.IsVerbatimStringLiteral ()) { if (offset <= tokenSpan.Start) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 2), new TextSegment (tokenSpan.End - 1, 1), true); if (offset >= tokenSpan.End - 1) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 2), new TextSegment (tokenSpan.End - 1, 1), false); } else { if (offset <= tokenSpan.Start) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), true); if (offset >= tokenSpan.End - 1) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), false); } } if (token.IsKind (SyntaxKind.CharacterLiteralToken) && token.ToString().EndsWith ("\'", StringComparison.Ordinal)) { if (offset <= tokenSpan.Start) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), true); if (offset >= tokenSpan.End - 1) return new BraceMatchingResult (new TextSegment (tokenSpan.Start, 1), new TextSegment (tokenSpan.End - 1, 1), false); } return null; }
internal static List<InsertionPoint> GetInsertionPoints (IReadonlyTextDocument data, SemanticModel model, ITypeSymbol type, int part) { List<InsertionPoint> result = new List<InsertionPoint> (); type = model.GetEnclosingNamedType (part, default (CancellationToken)) as ITypeSymbol ?? type; var sourceSpan = new TextSpan (part, 0); var filePath = data.FileName; var declaringType = type.DeclaringSyntaxReferences.FirstOrDefault (dsr => dsr.SyntaxTree.FilePath == filePath && dsr.Span.Contains (sourceSpan)) ?? type.DeclaringSyntaxReferences.FirstOrDefault (); if (declaringType == null) return result; return GetInsertionPoints (data, type, result, sourceSpan, declaringType); }
public override Task<BraceMatchingResult?> GetMatchingBracesAsync (IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken) { BraceMatchingResult? result = null; var matching = SimpleBracketMatcher.GetMatchingBracketOffset (editor, offset, cancellationToken); if (matching >= 0) { int start = Math.Min (offset, matching); int end = Math.Max (offset, matching); result = new BraceMatchingResult (new TextSegment (start, 1), new TextSegment (end, 1), offset == start); } return Task.FromResult (result); }
public Task<Projection> CreateProjection (DocumentInfo info, IReadonlyTextDocument data, bool buildExpressions) { if (info == null) throw new ArgumentNullException ("info"); if (data == null) throw new ArgumentNullException ("data"); var document = new StringBuilder (); WriteUsings (info.Imports, document); var segBuilder = System.Collections.Immutable.ImmutableList<ProjectedSegment>.Empty.ToBuilder (); foreach (var node in info.XScriptBlocks) { var start = data.LocationToOffset (node.Region.Begin.Line, node.Region.Begin.Column) + 2; var end = data.LocationToOffset (node.Region.End.Line, node.Region.End.Column) - 2; segBuilder.Add (new ProjectedSegment (start, document.Length, end - start)); document.AppendLine (data.GetTextBetween (start, end)); } if (buildExpressions) { WriteClassDeclaration (info, document); document.AppendLine ("{"); document.AppendLine ("void Generated ()"); document.AppendLine ("{"); //Console.WriteLine ("start:" + location.BeginLine +"/" +location.BeginColumn); foreach (var node in info.XExpressions) { bool isBlock = node is WebFormsRenderBlock; var start = data.LocationToOffset (node.Region.Begin.Line, node.Region.Begin.Column) + 2; var end = data.LocationToOffset (node.Region.End.Line, node.Region.End.Column) - 2; if (!isBlock) { document.Append ("WriteLine ("); start += 1; } string expr = data.GetTextBetween (start, end); segBuilder.Add (new ProjectedSegment (start, document.Length, expr.Length)); document.Append (expr); if (!isBlock) document.Append (");"); } document.AppendLine ("}"); document.AppendLine ("}"); } return Task.FromResult(new Projection ( TextEditorFactory.CreateNewDocument (new StringTextSource (document.ToString ()), info.AspNetDocument.FileName + ".g.cs", "text/x-csharp"), segBuilder.ToImmutable () )); }
static int StartsWithListMember (IReadonlyTextDocument document, IList<string> list, int offset) { if (document == null) throw new ArgumentNullException ("document"); if (list == null) throw new ArgumentNullException ("list"); for (int i = 0; i < list.Count; i++) { string item = list [i]; if (offset + item.Length < document.Length) { if (document.GetTextAt (offset, item.Length) == item) return i; } } return -1; }
public static List<InsertionPoint> GetInsertionPoints (IReadonlyTextDocument data, MonoDevelop.Ide.TypeSystem.ParsedDocument parsedDocument, ITypeSymbol type, int part) { if (data == null) throw new ArgumentNullException (nameof (data)); if (parsedDocument == null) throw new ArgumentNullException (nameof (parsedDocument)); if (type == null) throw new ArgumentNullException (nameof (type)); if (!type.IsDefinedInSource ()) throw new ArgumentException ("The given type needs to be defined in source code.", nameof (type)); // update type from parsed document, since this is always newer. //type = parsedDocument.GetInnermostTypeDefinition (type.GetLocation ()) ?? type; //var realStartLocation = data.OffsetToLocation (offset); var model = parsedDocument.GetAst<SemanticModel> (); return GetInsertionPoints (data, model, type, part); }
public static int GetMatchingBracketOffset (IReadonlyTextDocument document, int offset, CancellationToken cancellationToken = default(CancellationToken)) { if (offset < 0 || offset >= document.Length) return -1; char ch = document.GetCharAt (offset); int bracket = openBrackets.IndexOf (ch); int result; if (bracket >= 0) { result = SearchMatchingBracketForward (document, offset + 1, closingBrackets [bracket], openBrackets [bracket], cancellationToken); } else { bracket = closingBrackets.IndexOf (ch); if (bracket >= 0) { result = SearchMatchingBracketBackward (document, offset - 1, openBrackets [bracket], closingBrackets [bracket], cancellationToken); } else { result = -1; } } return result; }
public static async Task<DebugDataTipInfo> ResolveAsync (IReadonlyTextDocument editor, DocumentContext document, int offset, CancellationToken cancellationToken) { var analysisDocument = document.AnalysisDocument; DebugDataTipInfo result; CompilationUnitSyntax compilationUnit = null; if (analysisDocument == null) { compilationUnit = SyntaxFactory.ParseCompilationUnit (editor.Text); result = GetInfo (compilationUnit, null, offset, default(CancellationToken)); } else { compilationUnit = await analysisDocument.GetCSharpSyntaxRootAsync (cancellationToken).ConfigureAwait (false); var semantic = document.ParsedDocument?.GetAst<SemanticModel> (); if (semantic == null) { semantic = await analysisDocument.GetSemanticModelAsync (cancellationToken).ConfigureAwait (false); } result = GetInfo (compilationUnit, semantic, offset, default(CancellationToken)); } if (result.IsDefault || !result.Span.Contains(offset)) { return new DebugDataTipInfo (result.Span, null); } else if (result.Text == null) { return new DebugDataTipInfo (result.Span, compilationUnit.GetText ().ToString (result.Span)); } else { return result; } }
// public static void QueueQuickFixAnalysis (Document doc, TextLocation loc, CancellationToken token, Action<List<CodeAction>> callback) // { // var ext = doc.GetContent<MonoDevelop.AnalysisCore.Gui.ResultsEditorExtension> (); // var issues = ext != null ? ext.GetResultsAtOffset (doc.Editor.LocationToOffset (loc), token).OrderBy (r => r.Level).ToList () : new List<Result> (); // // ThreadPool.QueueUserWorkItem (delegate { // try { // var result = new List<CodeAction> (); // foreach (var r in issues) { // if (token.IsCancellationRequested) // return; // var fresult = r as FixableResult; // if (fresult == null) // continue; //// foreach (var action in FixOperationsHandler.GetActions (doc, fresult)) { //// result.Add (new AnalysisContextActionProvider.AnalysisCodeAction (action, r) { //// DocumentRegion = action.DocumentRegion //// }); //// } // } // result.AddRange (GetValidActions (doc, loc).Result); // callback (result); // } catch (Exception ex) { // LoggingService.LogError ("Error in analysis service", ex); // } // }); // } public static MonoDevelop.Ide.Editor.DocumentLocation GetCorrectResolveLocation(IReadonlyTextDocument editor, MonoDevelop.Ide.Editor.DocumentLocation location) { if (editor == null || location.Column == 1) { return(location); } /*if (editor is TextEditor) { * if (((TextEditor)editor).IsSomethingSelected) * return ((TextEditor)editor).SelectionRegion.Begin; * }*/ var line = editor.GetLine(location.Line); if (line == null || location.Column > line.LengthIncludingDelimiter) { return(location); } int offset = editor.LocationToOffset(location); if (offset > 0 && !char.IsLetterOrDigit(editor.GetCharAt(offset)) && char.IsLetterOrDigit(editor.GetCharAt(offset - 1))) { return(new MonoDevelop.Ide.Editor.DocumentLocation(location.Line, location.Column - 1)); } return(location); }
static int SearchMatchingBracketBackward (IReadonlyTextDocument document, int offset, char openBracket, char closingBracket, CancellationToken cancellationToken) { bool isInBlockComment = false; bool isInLineComment = false; int curStringQuote = -1; IList<string> blockCommentStarts = GetList (document, "BlockCommentStart"); IList<string> blockCommentEnds = GetList (document, "BlockCommentEnd"); IList<string> stringQuotes = GetList (document, "StringQuote"); bool startsInLineComment = StartsInLineComment (document, offset); int depth = -1; if (!startsInLineComment) offset = GetLastSourceCodePosition (document, offset); while (offset >= 0 && offset < document.Length) { if (offset % 100 == 0 && cancellationToken.IsCancellationRequested) return -1; char ch = document.GetCharAt (offset); // check block comments if (!isInLineComment && curStringQuote < 0) { if (!isInBlockComment) { isInBlockComment = StartsWithListMember (document, blockCommentEnds, offset) >= 0; } else { isInBlockComment = StartsWithListMember (document, blockCommentStarts, offset) < 0; } } if (!isInBlockComment && !isInLineComment) { int i = StartsWithListMember (document, stringQuotes, offset); if (i >= 0) { if (curStringQuote >= 0) { if (curStringQuote == i) curStringQuote = -1; } else { curStringQuote = i; } } } switch (ch) { case '\n': case '\r': if (startsInLineComment) return -1; offset--; while (offset > 0 && (document.GetCharAt (offset) == '\n' || document.GetCharAt (offset) == '\r')) { offset--; } offset = GetLastSourceCodePosition (document, offset) + 1; break; default: if (ch == closingBracket) { if (!(curStringQuote >= 0 || isInBlockComment)) --depth; } else if (ch == openBracket) { if (!(curStringQuote >= 0 || isInBlockComment)) { ++depth; if (depth == 0) return offset; } } break; } offset--; } return -1; }
static bool StartsInLineComment (IReadonlyTextDocument document, int offset) { IList<string> lineComments = GetList (document, "LineComment"); var line = document.GetLineByOffset (offset); for (int i = line.Offset; i < offset; i++) { if (StartsWithListMember (document, lineComments, i) >= 0) return true; } return false; }
public static TextEditor CreateNewEditor (IReadonlyTextDocument document, TextEditorType textEditorType = TextEditorType.Default) { if (document == null) throw new System.ArgumentNullException ("document"); var result = new TextEditor (currentFactory.CreateNewEditor (document), textEditorType) { ZoomLevel = zoomLevel }; result.ZoomLevelChanged += delegate { zoomLevel.Value = result.ZoomLevel; }; return result; }
public static string GetDiffAsString (this IReadonlyTextDocument document, IReadonlyTextDocument changedDocument, bool includeEol = true) { if (document == null) throw new ArgumentNullException ("document"); if (changedDocument == null) throw new ArgumentNullException ("changedDocument"); return Diff.GetDiffString (GetDiff (document, changedDocument, includeEol), document, changedDocument, document.FileName, changedDocument.FileName); }
static int [] GetDiffCodes (IReadonlyTextDocument document, ref int codeCounter, Dictionary<string, int> codeDictionary, DiffOptions options) { int i = 0; var result = new int [document.LineCount]; foreach (var line in document.GetLinesStartingAt (1)) { string lineText = document.GetTextAt (line.Offset, options.IncludeEol ? line.LengthIncludingDelimiter : line.Length); if (options.TrimLines) lineText = lineText.Trim (); int curCode; if (!codeDictionary.TryGetValue (lineText, out curCode)) { codeDictionary [lineText] = curCode = ++codeCounter; } result [i] = curCode; i++; } return result; }
public static MSBuildResolveResult Resolve( XmlParser parser, IReadonlyTextDocument document, MSBuildDocument context) { int offset = parser.Position; //clones and connects nodes to their parents parser = parser.GetTreeParser(); var nodePath = parser.Nodes.ToList(); nodePath.Reverse(); //capture incomplete names, attributes and element values int i = offset; if (parser.CurrentState is XmlRootState && parser.Nodes.Peek() is XElement unclosedEl) { while (i < document.Length && InRootOrClosingTagState() && !unclosedEl.IsClosed) { parser.Push(document.GetCharAt(i++)); } } else { while (i < document.Length && InNameOrAttributeState()) { parser.Push(document.GetCharAt(i++)); } } //if nodes are incomplete, they won't get connected //HACK: the only way to reconnect them is reflection if (nodePath.Count > 1) { for (int idx = 1; idx < nodePath.Count; idx++) { var node = nodePath [idx]; if (node.Parent == null) { var parent = nodePath [idx - 1]; ParentProp.SetValue(node, parent); } } } //need to look up element by walking how the path, since at each level, if the parent has special children, //then that gives us information to identify the type of its children MSBuildLanguageElement languageElement = null; MSBuildLanguageAttribute languageAttribute = null; XElement el = null; XAttribute att = null; foreach (var node in nodePath) { if (node is XAttribute xatt && xatt.Name.Prefix == null) { att = xatt; languageAttribute = languageElement?.GetAttribute(att.Name.Name); break; } //if children of parent is known to be arbitrary data, don't go into it if (languageElement != null && languageElement.ValueKind == MSBuildValueKind.Data) { break; } //code completion is forgiving, all we care about best guess resolve for deepest child if (node is XElement xel && xel.Name.Prefix == null) { el = xel; languageElement = MSBuildLanguageElement.Get(el.Name.Name, languageElement); if (languageElement != null) { continue; } } languageElement = null; } if (languageElement == null) { return(null); } var rr = new MSBuildResolveResult { LanguageElement = languageElement, LanguageAttribute = languageAttribute, XElement = el, XAttribute = att }; var rv = new MSBuildResolveVisitor(offset, rr); rv.Run(el, languageElement, document.FileName, document, context); return(rr); bool InNameOrAttributeState() => parser.CurrentState is XmlNameState || parser.CurrentState is XmlAttributeState || parser.CurrentState is XmlAttributeValueState; bool InRootOrClosingTagState() => parser.CurrentState is XmlRootState || parser.CurrentState is XmlNameState || parser.CurrentState is XmlClosingTagState; }
static int SearchMatchingBracket(IReadonlyTextDocument editor, int offset, char openBracket, char closingBracket, int direction) { bool isInString = false; bool isInChar = false; bool isInBlockComment = false; int depth = -1; while (offset >= 0 && offset < editor.Length) { char ch = editor.GetCharAt(offset); switch (ch) { case '/': if (isInBlockComment) { isInBlockComment = editor.GetCharAt(offset + direction) != '*'; } if (!isInString && !isInChar && offset - direction < editor.Length) { isInBlockComment = offset > 0 && editor.GetCharAt(offset - direction) == '*'; } break; case '"': if (!isInChar && !isInBlockComment) { isInString = !isInString; } break; case '\'': if (!isInString && !isInBlockComment) { isInChar = !isInChar; } break; default: if (ch == closingBracket) { if (!(isInString || isInChar || isInBlockComment)) { --depth; } } else if (ch == openBracket) { if (!(isInString || isInChar || isInBlockComment)) { ++depth; if (depth == 0) { return(offset); } } } break; } offset += direction; } return(-1); }
internal Task <ParsedDocumentProjection> ParseProjection(Project project, IReadonlyTextDocument data, CancellationToken cancellationToken = default(CancellationToken)) { return(ParseProjection(project, data.FileName, data.MimeType, data, cancellationToken)); }
public Task <ParsedDocument> ParseFile(Project project, IReadonlyTextDocument data, CancellationToken cancellationToken = default(CancellationToken)) { return(ParseFile(project, data.FileName, data.MimeType, data, cancellationToken)); }
public override async Task <BraceMatchingResult?> GetMatchingBracesAsync(IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken = default(CancellationToken)) { if (context.ParsedDocument == null) { return(await fallback.GetMatchingBracesAsync(editor, context, offset, cancellationToken)); } var analysisDocument = context.AnalysisDocument; if (analysisDocument == null) { return(null); } var partialDoc = analysisDocument.WithFrozenPartialSemantics(cancellationToken); var root = await partialDoc.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); if (offset < 0 || root.Span.End <= offset) { return(null); } var trivia = root.FindTrivia(offset).GetStructure() as DirectiveTriviaSyntax; if (trivia != null && (trivia.IsKind(SyntaxKind.RegionDirectiveTrivia) || trivia.IsKind(SyntaxKind.EndRegionDirectiveTrivia))) { var matching = trivia.GetMatchingDirective(cancellationToken); if (matching == null) { return(null); } if (trivia.IsKind(SyntaxKind.RegionDirectiveTrivia)) { return(new BraceMatchingResult( new TextSegment(trivia.Span.Start, trivia.Span.Length), new TextSegment(matching.Span.Start, matching.Span.Length), true, BraceMatchingProperties.Hidden)); } else { return(new BraceMatchingResult( new TextSegment(matching.Span.Start, matching.Span.Length), new TextSegment(trivia.Span.Start, trivia.Span.Length), false, BraceMatchingProperties.Hidden)); } } var token = root.FindToken(offset); var tokenSpan = token.Span; if (offset < tokenSpan.Start || offset >= tokenSpan.End) { return(null); } for (int i = 0; i < tokenPairs.Length / 2; i++) { var open = tokenPairs [i * 2]; var close = tokenPairs [i * 2 + 1]; SyntaxToken match; if (token.IsKind(open)) { if (TryFindMatchingToken(token, out match, open, close)) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, tokenSpan.Length), new TextSegment(match.Span.Start, match.Span.Length), true)); } } else if (token.IsKind(close)) { if (TryFindMatchingToken(token, out match, open, close)) { return(new BraceMatchingResult(new TextSegment(match.Span.Start, match.Span.Length), new TextSegment(tokenSpan.Start, tokenSpan.Length), false)); } } } if (token.IsKind(SyntaxKind.StringLiteralToken) && token.ToString().EndsWith("\"", StringComparison.Ordinal)) { if (token.IsVerbatimStringLiteral()) { if (offset <= tokenSpan.Start) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 2), new TextSegment(tokenSpan.End - 1, 1), true)); } if (offset >= tokenSpan.End - 1) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 2), new TextSegment(tokenSpan.End - 1, 1), false)); } } else { if (offset <= tokenSpan.Start) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), true)); } if (offset >= tokenSpan.End - 1) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), false)); } } } if (token.IsKind(SyntaxKind.CharacterLiteralToken) && token.ToString().EndsWith("\'", StringComparison.Ordinal)) { if (offset <= tokenSpan.Start) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), true)); } if (offset >= tokenSpan.End - 1) { return(new BraceMatchingResult(new TextSegment(tokenSpan.Start, 1), new TextSegment(tokenSpan.End - 1, 1), false)); } } return(null); }
public PaketDependencyRulePart(IReadonlyTextDocument document, int start, int end) { Text = document.GetTextAt(start, end - start); Offset = start; EndOffset = end; }
public TestViewContent(IReadonlyTextDocument doc) { data = TextEditorFactory.CreateNewEditor(doc); Contents.Add(data); Name = ""; }
ITextEditorImpl ITextEditorFactory.CreateNewEditor(IReadonlyTextDocument document) { return(new SourceEditorView(document)); }
static List <InsertionPoint> GetInsertionPoints(IReadonlyTextDocument data, ITypeSymbol type, List <InsertionPoint> result, TextSpan sourceSpan, SyntaxReference declaringType) { var openBraceToken = declaringType.GetSyntax().ChildTokens().FirstOrDefault(t => t.IsKind(SyntaxKind.OpenBraceToken)); if (!openBraceToken.IsMissing) { var domLocation = data.OffsetToLocation(openBraceToken.SpanStart); result.Add(GetInsertionPosition(data, domLocation.Line, domLocation.Column)); // result.Add (GetInsertionPosition (data, realStartLocation.Line, realStartLocation.Column)); result [0].LineBefore = NewLineInsertion.None; } foreach (var member in type.GetMembers()) { if (member.IsImplicitlyDeclared || !member.IsDefinedInSource()) { continue; } //var domLocation = member.BodyRegion.End; foreach (var loc in member.DeclaringSyntaxReferences) { if (loc.SyntaxTree.FilePath != declaringType.SyntaxTree.FilePath || !declaringType.Span.Contains(sourceSpan)) { continue; } var domLocation = data.OffsetToLocation(loc.Span.End); if (domLocation.Line <= 0) { var lineSegment = data.GetLineByOffset(loc.Span.Start); if (lineSegment == null) { continue; } domLocation = new DocumentLocation(lineSegment.LineNumber, lineSegment.Length + 1); } result.Add(GetInsertionPosition(data, domLocation.Line, domLocation.Column)); break; } } result [result.Count - 1].LineAfter = NewLineInsertion.None; CheckStartPoint(data, result [0], result.Count == 1); if (result.Count > 1) { result.RemoveAt(result.Count - 1); NewLineInsertion insertLine; var typeSyntaxReference = type.DeclaringSyntaxReferences.FirstOrDefault(r => r.SyntaxTree.FilePath == data.FileName && r.Span.Contains(sourceSpan)); var lineBefore = data.GetLineByOffset(typeSyntaxReference.Span.End)?.PreviousLine; if (lineBefore != null && lineBefore.Length == lineBefore.GetIndentation(data).Length) { insertLine = NewLineInsertion.None; } else { insertLine = NewLineInsertion.Eol; } // search for line start var line = data.GetLineByOffset(typeSyntaxReference.Span.End); int col = typeSyntaxReference.Span.End - line.Offset; if (line != null) { var lineOffset = line.Offset; col = Math.Min(line.Length, col); while (lineOffset + col - 2 >= 0 && col > 1 && char.IsWhiteSpace(data.GetCharAt(lineOffset + col - 2))) { col--; } } result.Add(new InsertionPoint(new DocumentLocation(line.LineNumber, col), insertLine, NewLineInsertion.Eol)); CheckEndPoint(data, result [result.Count - 1], result.Count == 1); } // foreach (var region in parsedDocument.UserRegions.Where (r => type.BodyRegion.IsInside (r.Region.Begin))) { // result.Add (new InsertionPoint (new DocumentLocation (region.Region.BeginLine + 1, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // result.Add (new InsertionPoint (new DocumentLocation (region.Region.EndLine, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // result.Add (new InsertionPoint (new DocumentLocation (region.Region.EndLine + 1, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // } result.Sort((left, right) => left.Location.CompareTo(right.Location)); //foreach (var res in result) // Console.WriteLine (res); return(result); }
ITextEditorImpl ITextEditorFactory.CreateNewEditor (IReadonlyTextDocument document) { return new SourceEditorView (document); }
static InsertionPoint GetInsertionPosition (IReadonlyTextDocument doc, int line, int column) { int bodyEndOffset = doc.LocationToOffset (line, column) + 1; var curLine = doc.GetLine (line); if (curLine != null) { if (bodyEndOffset < curLine.Offset + curLine.Length) { // case1: positition is somewhere inside the start line return new InsertionPoint (new DocumentLocation (line, column + 1), NewLineInsertion.Eol, NewLineInsertion.BlankLine); } } // -> if position is at line end check next line var nextLine = doc.GetLine (line + 1); if (nextLine == null) // check for 1 line case. return new InsertionPoint (new DocumentLocation (line, column + 1), NewLineInsertion.BlankLine, NewLineInsertion.BlankLine); for (int i = nextLine.Offset; i < nextLine.EndOffset; i++) { char ch = doc.GetCharAt (i); if (!char.IsWhiteSpace (ch)) { // case2: next line contains non ws chars. return new InsertionPoint (new DocumentLocation (line + 1, 1), NewLineInsertion.Eol, NewLineInsertion.BlankLine); } } var nextLine2 = doc.GetLine (line + 2); if (nextLine2 != null) { for (int i = nextLine2.Offset; i < nextLine2.EndOffset; i++) { char ch = doc.GetCharAt (i); if (!char.IsWhiteSpace (ch)) { // case3: one blank line return new InsertionPoint (new DocumentLocation (line + 1, 1), NewLineInsertion.Eol, NewLineInsertion.Eol); } } } // case4: more than 1 blank line return new InsertionPoint (new DocumentLocation (line + 1, 1), NewLineInsertion.Eol, NewLineInsertion.None); }
public static IEnumerable<DiffHunk> GetDiff (this IReadonlyTextDocument document, IReadonlyTextDocument changedDocument, DiffOptions options) { if (document == null) throw new ArgumentNullException ("document"); if (changedDocument == null) throw new ArgumentNullException ("changedDocument"); var codeDictionary = new Dictionary<string, int> (); int codeCounter = 0; return Diff.GetDiff<int> (GetDiffCodes (document, ref codeCounter, codeDictionary, options), GetDiffCodes (changedDocument, ref codeCounter, codeDictionary, options)); }
internal static InsertionPoint GetSuitableInsertionPoint (IReadonlyTextDocument data, IEnumerable<InsertionPoint> points, ITypeSymbol cls, Location part, SyntaxNode member) { switch (member.Kind ()) { case SyntaxKind.FieldDeclaration: return GetNewFieldPosition (data, points, cls, part); case SyntaxKind.MethodDeclaration: case SyntaxKind.ConstructorDeclaration: case SyntaxKind.DestructorDeclaration: case SyntaxKind.OperatorDeclaration: return GetNewMethodPosition (data, points, cls, part); case SyntaxKind.EventDeclaration: return GetNewEventPosition (data, points, cls, part); case SyntaxKind.PropertyDeclaration: return GetNewPropertyPosition (data, points, cls, part); } throw new InvalidOperationException ("Invalid member type: " + member.Kind ()); }
public static TextEditor CreateNewEditor (DocumentContext ctx, IReadonlyTextDocument document, TextEditorType textEditorType = TextEditorType.Default) { var result = CreateNewEditor (document, textEditorType); result.InitializeExtensionChain (ctx); return result; }
static InsertionPoint GetNewEventPosition (IReadonlyTextDocument data, IEnumerable<InsertionPoint> points, ITypeSymbol cls, Location part) { if (!cls.GetMembers ().OfType<IEventSymbol> ().Any ()) return GetNewMethodPosition (data, points, cls, part); var lastEvent = cls.GetMembers ().OfType<IEventSymbol> ().Last (); var begin = data.OffsetToLocation (lastEvent.Locations.First ().SourceSpan.Start); return points.FirstOrDefault (p => p.Location > begin); }
public TextLineCollectionWrapper (MonoDevelopSourceText parent, IReadonlyTextDocument textDoc) { this.parent = parent; this.textDoc = textDoc; }
static string [] GetList (IReadonlyTextDocument document, string name) { return TextEditorFactory.GetSyntaxProperties (document.MimeType, name) ?? emptyList; }
static int GetLastSourceCodePosition (IReadonlyTextDocument document, int lineOffset) { var line = document.GetLineByOffset (lineOffset); bool isInBlockComment = false; bool isInLineComment = false; int curStringQuote = -1; IList<string> lineComments = GetList (document, "LineComment"); IList<string> blockCommentStarts = GetList (document, "BlockCommentStart"); IList<string> blockCommentEnds = GetList (document, "BlockCommentEnd"); IList<string> stringQuotes = GetList (document, "StringQuote"); for (int i = 0; i < line.Length; i++) { int offset = line.Offset + i; // check line comments if (!isInBlockComment && curStringQuote < 0) { isInLineComment = StartsWithListMember (document, lineComments, offset) >= 0; if (isInLineComment) return System.Math.Min (offset, lineOffset); } // check block comments if (!isInLineComment && curStringQuote < 0) { if (!isInBlockComment) { isInBlockComment = StartsWithListMember (document, blockCommentStarts, offset) >= 0; } else { isInBlockComment = StartsWithListMember (document, blockCommentEnds, offset) < 0; } } if (!isInBlockComment && !isInLineComment) { int j = StartsWithListMember (document, stringQuotes, offset); if (j >= 0) { if (curStringQuote >= 0) { if (curStringQuote == j) curStringQuote = -1; } else { curStringQuote = j; } } } } return lineOffset; }
static int SearchMatchingBracketForward (IReadonlyTextDocument document, int offset, char openBracket, char closingBracket, CancellationToken cancellationToken) { bool isInBlockComment = false; bool isInLineComment = false; int curStringQuote = -1; bool startsInLineComment = StartsInLineComment (document, offset); var lineComments = GetList (document, "LineComment"); var blockCommentStarts = GetList (document, "BlockCommentStart"); var blockCommentEnds = GetList (document, "BlockCommentEnd"); var stringQuotes = GetList (document, "StringQuote"); int depth = -1; while (offset >= 0 && offset < document.Length) { if (offset % 100 == 0 && cancellationToken.IsCancellationRequested) return -1; if (curStringQuote < 0) { // check line comments if (!isInBlockComment && !isInLineComment) isInLineComment = StartsWithListMember (document, lineComments, offset) >= 0; // check block comments if (!isInLineComment) { if (!isInBlockComment) { isInBlockComment = StartsWithListMember (document, blockCommentStarts, offset) >= 0; } else { isInBlockComment = StartsWithListMember (document, blockCommentEnds, offset) < 0; } } } if (!isInBlockComment && !isInLineComment) { int i = StartsWithListMember (document, stringQuotes, offset); if (i >= 0) { if (curStringQuote >= 0) { if (curStringQuote == i) curStringQuote = -1; } else { curStringQuote = i; } } } char ch = document.GetCharAt (offset); switch (ch) { case '\n': case '\r': if (startsInLineComment) return -1; isInLineComment = false; break; default: if (ch == closingBracket) { if (!(isInLineComment || curStringQuote >= 0 || isInBlockComment)) --depth; } else if (ch == openBracket) { if (!(isInLineComment || curStringQuote >= 0 || isInBlockComment)) { ++depth; if (depth == 0) return offset; } } break; } offset++; } return -1; }
public static List <InsertionPoint> GetInsertionPoints(IReadonlyTextDocument data, SemanticModel model, ITypeSymbol type, Location location) { return(GetInsertionPoints(data, model, type, location.SourceSpan.Start)); }
static bool IsBlankLine(IReadonlyTextDocument doc, int i) { var line = doc.GetLine(i); return(line.Length == line.GetIndentation(doc).Length); }
static bool IsSemicolonalreadyPlaced (IReadonlyTextDocument data, int caretOffset) { for (int pos2 = caretOffset - 1; pos2-- > 0;) { var ch2 = data.GetCharAt (pos2); if (ch2 == ';') { return true; } if (!char.IsWhiteSpace (ch2)) return false; } return false; }
static bool IsBlankLine (IReadonlyTextDocument doc, int i) { var line = doc.GetLine (i); return line.Length == line.GetIndentation (doc).Length; }
static List<InsertionPoint> GetInsertionPoints (IReadonlyTextDocument data, ITypeSymbol type, List<InsertionPoint> result, TextSpan sourceSpan, SyntaxReference declaringType) { var openBraceToken = declaringType.GetSyntax ().ChildTokens ().FirstOrDefault (t => t.IsKind (SyntaxKind.OpenBraceToken)); if (!openBraceToken.IsMissing) { var domLocation = data.OffsetToLocation (openBraceToken.SpanStart); result.Add (GetInsertionPosition (data, domLocation.Line, domLocation.Column)); // result.Add (GetInsertionPosition (data, realStartLocation.Line, realStartLocation.Column)); result [0].LineBefore = NewLineInsertion.None; } foreach (var member in type.GetMembers ()) { if (member.IsImplicitlyDeclared || !member.IsDefinedInSource ()) continue; //var domLocation = member.BodyRegion.End; foreach (var loc in member.DeclaringSyntaxReferences) { if (loc.SyntaxTree.FilePath != declaringType.SyntaxTree.FilePath || !declaringType.Span.Contains (sourceSpan)) continue; var domLocation = data.OffsetToLocation (loc.Span.End); if (domLocation.Line <= 0) { var lineSegment = data.GetLineByOffset (loc.Span.Start); if (lineSegment == null) continue; domLocation = new DocumentLocation (lineSegment.LineNumber, lineSegment.Length + 1); } result.Add (GetInsertionPosition (data, domLocation.Line, domLocation.Column)); break; } } result [result.Count - 1].LineAfter = NewLineInsertion.None; CheckStartPoint (data, result [0], result.Count == 1); if (result.Count > 1) { result.RemoveAt (result.Count - 1); NewLineInsertion insertLine; var typeSyntaxReference = type.DeclaringSyntaxReferences.FirstOrDefault (r => r.Span.Contains (sourceSpan)); var lineBefore = data.GetLineByOffset (typeSyntaxReference.Span.End).PreviousLine; if (lineBefore != null && lineBefore.Length == lineBefore.GetIndentation (data).Length) { insertLine = NewLineInsertion.None; } else { insertLine = NewLineInsertion.Eol; } // search for line start var line = data.GetLineByOffset (typeSyntaxReference.Span.End); int col = typeSyntaxReference.Span.End - line.Offset; if (line != null) { var lineOffset = line.Offset; col = Math.Min (line.Length, col); while (lineOffset + col - 2 >= 0 && col > 1 && char.IsWhiteSpace (data.GetCharAt (lineOffset + col - 2))) col--; } result.Add (new InsertionPoint (new DocumentLocation (line.LineNumber, col), insertLine, NewLineInsertion.Eol)); CheckEndPoint (data, result [result.Count - 1], result.Count == 1); } // foreach (var region in parsedDocument.UserRegions.Where (r => type.BodyRegion.IsInside (r.Region.Begin))) { // result.Add (new InsertionPoint (new DocumentLocation (region.Region.BeginLine + 1, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // result.Add (new InsertionPoint (new DocumentLocation (region.Region.EndLine, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // result.Add (new InsertionPoint (new DocumentLocation (region.Region.EndLine + 1, 1), NewLineInsertion.Eol, NewLineInsertion.Eol)); // } result.Sort ((left, right) => left.Location.CompareTo (right.Location)); //foreach (var res in result) // Console.WriteLine (res); return result; }
public static List <InsertionPoint> GetInsertionPoints(IReadonlyTextDocument data, ParsedDocument parsedDocument, ITypeSymbol type, Location location) { return(GetInsertionPoints(data, parsedDocument, type, location.SourceSpan.Start)); }
public static bool GuessSemicolonInsertionOffset (IReadonlyTextDocument data, MonoDevelop.Core.Text.ISegment curLine, int caretOffset, out int outOffset) { int lastNonWsOffset = caretOffset; char lastNonWsChar = '\0'; outOffset = caretOffset; int max = curLine.EndOffset; int end = caretOffset; while (end > 1 && char.IsWhiteSpace (data.GetCharAt (end))) end--; int end2 = end; while (end2 > 1 && char.IsLetter (data.GetCharAt (end2 - 1))) end2--; if (end != end2) { string token = data.GetTextBetween (end2, end + 1); // guess property context if (token == "get" || token == "set") return false; } var offset = curLine.Offset; string lineText = data.GetTextAt (caretOffset, max - caretOffset); var lexer = new ICSharpCode.NRefactory.CSharp.Completion.CSharpCompletionEngineBase.MiniLexer (lineText); lexer.Parse ((ch, i) => { if (lexer.IsInSingleComment || lexer.IsInMultiLineComment) return true; if (ch == '}' && lexer.IsFistNonWs && !IsSemicolonalreadyPlaced (data, caretOffset)) { lastNonWsChar = ';'; return true; } if (!char.IsWhiteSpace (ch)) { lastNonWsOffset = caretOffset + i; lastNonWsChar = ch; } return false; }); // if the line ends with ';' the line end is not the correct place for a new semicolon. if (lastNonWsChar == ';') return false; outOffset = lastNonWsOffset; return true; }
public abstract Task<BraceMatchingResult?> GetMatchingBracesAsync(IReadonlyTextDocument editor, DocumentContext context, int offset, CancellationToken cancellationToken = default(CancellationToken));
public SourceEditorView (IReadonlyTextDocument document = null) { Counters.LoadedEditors++; widget = new SourceEditorWidget (this); if (document != null) { var textDocument = document as TextDocument; if (textDocument != null) { widget.TextEditor.Document = textDocument; } else { widget.TextEditor.Document.Text = document.Text; } } widget.TextEditor.Document.TextReplaced += HandleTextReplaced; widget.TextEditor.Document.LineChanged += HandleLineChanged; widget.TextEditor.Document.LineInserted += HandleLineChanged; widget.TextEditor.Document.LineRemoved += HandleLineChanged; widget.TextEditor.Document.BeginUndo += HandleBeginUndo; widget.TextEditor.Document.EndUndo += HandleEndUndo; widget.TextEditor.Document.TextReplacing += OnTextReplacing; widget.TextEditor.Document.TextReplaced += OnTextReplaced; widget.TextEditor.Document.ReadOnlyCheckDelegate = CheckReadOnly; widget.TextEditor.TextViewMargin.LineShown += TextViewMargin_LineShown; // widget.TextEditor.Document.DocumentUpdated += delegate { // this.IsDirty = Document.IsDirty; // }; widget.TextEditor.Caret.PositionChanged += HandlePositionChanged; widget.TextEditor.IconMargin.ButtonPressed += OnIconButtonPress; ClipbardRingUpdated += UpdateClipboardRing; TextEditorService.FileExtensionAdded += HandleFileExtensionAdded; TextEditorService.FileExtensionRemoved += HandleFileExtensionRemoved; breakpoints = DebuggingService.Breakpoints; DebuggingService.DebugSessionStarted += OnDebugSessionStarted; DebuggingService.StoppedEvent += HandleTargetExited; DebuggingService.ExecutionLocationChanged += OnExecutionLocationChanged; DebuggingService.CurrentFrameChanged += OnCurrentFrameChanged; DebuggingService.StoppedEvent += OnCurrentFrameChanged; DebuggingService.ResumedEvent += OnCurrentFrameChanged; breakpoints.BreakpointAdded += OnBreakpointAdded; breakpoints.BreakpointRemoved += OnBreakpointRemoved; breakpoints.BreakpointStatusChanged += OnBreakpointStatusChanged; breakpoints.BreakpointModified += OnBreakpointStatusChanged; DebuggingService.PinnedWatches.WatchAdded += OnWatchAdded; DebuggingService.PinnedWatches.WatchRemoved += OnWatchRemoved; DebuggingService.PinnedWatches.WatchChanged += OnWatchChanged; TaskService.Errors.TasksAdded += UpdateTasks; TaskService.Errors.TasksRemoved += UpdateTasks; TaskService.JumpedToTask += HandleTaskServiceJumpedToTask; IdeApp.Preferences.ShowMessageBubbles.Changed += HandleIdeAppPreferencesShowMessageBubblesChanged; TaskService.TaskToggled += HandleErrorListPadTaskToggled; widget.TextEditor.Options.Changed += HandleWidgetTextEditorOptionsChanged; IdeApp.Preferences.DefaultHideMessageBubbles.Changed += HandleIdeAppPreferencesDefaultHideMessageBubblesChanged; Document.AddAnnotation (this); if (document != null) { Document.MimeType = document.MimeType; Document.FileName = document.FileName; } FileRegistry.Add (this); }
public async Task CreateTextDocumentAsync(string text) { var textSource = new StringTextSource(text); document = await SimpleReadonlyDocument.CreateReadonlyDocumentAsync(textSource); }