public void OnReturn(IBraceCompletionSession session) { if (NodejsPackage.Instance.FormattingGeneralOptionsPage.FormatOnEnter) { // reshape code from // { // |} // // to // { // | // } // where | indicates caret position. var closingPointPosition = session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot); Debug.Assert( condition: closingPointPosition > 0, message: "The closing point position should always be greater than zero", detailMessage: "The closing point position should always be greater than zero, " + "since there is also an opening point for this brace completion session"); // Insert an extra newline and indent the closing brace manually. session.SubjectBuffer.Insert( closingPointPosition - 1, VsExtensions.GetNewLineText(session.TextView.TextSnapshot)); // Format before setting the caret. Format(session); // After editing, set caret to the correct position. SetCaretPosition(session); } }
/// <summary> /// Called by the editor when return is pressed while both /// braces are on the same line and no typing has occurred /// in the session. /// </summary> /// <remarks> /// Called after the newline has been inserted into the buffer. /// Formatting for scenarios where the closing brace needs to be /// moved down an additional line past the caret should be done here. /// </remarks> /// <param name="session">Default brace completion session</param> public void OnReturn(IBraceCompletionSession session) { if (session.OpeningBrace == '{' && REditorSettings.AutoFormat) { AutoFormat.IgnoreOnce = true; EnsureTreeReady(session.SubjectBuffer); FormatOperations.FormatCurrentScope(session.TextView, session.SubjectBuffer, indentCaret: true); } }
private static void SetCaretPosition(IBraceCompletionSession session) { // Find next line from brace. var snapshot = session.SubjectBuffer.CurrentSnapshot; var openCurlyLine = session.OpeningPoint.GetPoint(snapshot).GetContainingLine(); var nextLineNumber = openCurlyLine.LineNumber + 1; bool nextLineExists = nextLineNumber < snapshot.LineCount; Debug.Assert(nextLineExists, "There are no lines after this brace completion's opening brace, no place to seek caret to."); if (!nextLineExists) { // Don't move the caret as we have somehow ended up without a line following our opening brace. return; } // Get indent for this line. ITextSnapshotLine nextLine = snapshot.GetLineFromLineNumber(nextLineNumber); var indentation = GetIndentationLevelForLine(session, nextLine); if (indentation > 0) { // before deleting, make sure this line is only whitespace. bool lineIsWhitepace = string.IsNullOrWhiteSpace(nextLine.GetText()); Debug.Assert(lineIsWhitepace, "The line after the brace should be empty."); if (lineIsWhitepace) { session.SubjectBuffer.Delete(nextLine.Extent); MoveCaretTo(session.TextView, nextLine.End, indentation); } } else { MoveCaretTo(session.TextView, nextLine.End); } }
/// <summary> /// Called before the session is added to the stack. /// </summary> /// <remarks> /// If additional formatting is required for the opening or /// closing brace it should be done here. /// </remarks> /// <param name="session">Default brace completion session</param> public void Start(IBraceCompletionSession session) { if (session.OpeningBrace == '{' && REditorSettings.AutoFormat) { AutoFormat.IgnoreOnce = false; EnsureTreeReady(session.SubjectBuffer); FormatOperations.FormatCurrentNode<IStatement>(session.TextView, session.SubjectBuffer); } }
/// <summary> /// Called after the session has been removed from the stack. /// </summary> /// <param name="session">Default brace completion session</param> public void Finish(IBraceCompletionSession session) { //if (session.OpeningBrace == '{' && REditorSettings.AutoFormat) { // AutoFormat.IgnoreOnce = false; // EnsureTreeReady(session.SubjectBuffer); // FormatOperations.FormatCurrentScope(session.TextView, session.SubjectBuffer, indentCaret: false); //} }
public override void AfterReturn(IBraceCompletionSession session, CancellationToken cancellationToken) { // check whether shape of the braces are what we support // shape must be either "{|}" or "{ }". | is where caret is. otherwise, we don't do any special behavior if (!ContainsOnlyWhitespace(session)) { return; } // alright, it is in right shape. var undoHistory = GetUndoHistory(session.TextView); using (var transaction = undoHistory.CreateTransaction(EditorFeaturesResources.Brace_Completion)) { var document = session.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { document.InsertText(session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot) - 1, Environment.NewLine, cancellationToken); FormatTrackingSpan(session, shouldHonorAutoFormattingOnCloseBraceOption: false, rules: GetFormattingRules(document)); // put caret at right indentation PutCaretOnLine(session, session.OpeningPoint.GetPoint(session.SubjectBuffer.CurrentSnapshot).GetContainingLineNumber() + 1); transaction.Complete(); } } }
private static bool ContainsOnlyWhitespace(IBraceCompletionSession session) { var span = session.GetSessionSpan(); var snapshot = span.Snapshot; var start = span.Start.Position; start = snapshot[start] == session.OpeningBrace ? start + 1 : start; var end = span.End.Position - 1; end = snapshot[end] == session.ClosingBrace ? end - 1 : end; if (!start.PositionInSnapshot(snapshot) || !end.PositionInSnapshot(snapshot)) { return false; } for (int i = start; i <= end; i++) { if (!char.IsWhiteSpace(snapshot[i])) { return false; } } return true; }
public bool TryCreateSession(ITextView textView, SnapshotPoint openingPoint, char openingBrace, char closingBrace, out IBraceCompletionSession session) { this.AssertIsForeground(); var textSnapshot = openingPoint.Snapshot; var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { var editorSessionFactory = document.GetLanguageService<IEditorBraceCompletionSessionFactory>(); if (editorSessionFactory != null) { // Brace completion is (currently) not cancellable. var cancellationToken = CancellationToken.None; var editorSession = editorSessionFactory.TryCreateSession(document, openingPoint, openingBrace, cancellationToken); if (editorSession != null) { var undoHistory = _undoManager.GetTextBufferUndoManager(textView.TextBuffer).TextBufferUndoHistory; session = new BraceCompletionSession( textView, openingPoint.Snapshot.TextBuffer, openingPoint, openingBrace, closingBrace, undoHistory, _editorOperationsFactoryService, editorSession); return true; } } } session = null; return false; }
public override bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var position = session.OpeningPoint.GetPosition(snapshot); var token = snapshot.FindToken(position, cancellationToken); // check token at the opening point first if (!IsValidToken(token) || token.RawKind != OpeningTokenKind || token.SpanStart != position || token.Parent == null) { return false; } // now check whether parser think whether there is already counterpart closing parenthesis var pair = token.Parent.GetParentheses(); // if pair is on the same line, then the closing parenthesis must belong to other tracker. // let it through if (snapshot.GetLineNumberFromPosition(pair.Item1.SpanStart) == snapshot.GetLineNumberFromPosition(pair.Item2.Span.End)) { return true; } return (int)pair.Item2.Kind() != ClosingTokenKind || pair.Item2.Span.Length == 0; }
public bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var position = session.OpeningPoint.GetPosition(snapshot); var token = snapshot.FindToken(position, cancellationToken); return token.IsKind(SyntaxKind.InterpolatedStringStartToken, SyntaxKind.InterpolatedVerbatimStringStartToken) && token.Span.End - 1 == position; }
internal void CheckBackspace(IBraceCompletionSession session) { session.TextView.TryMoveCaretToAndEnsureVisible(session.OpeningPoint.GetPoint(session.SubjectBuffer.CurrentSnapshot).Add(1)); session.PreBackspace(out var handled); if (!handled) { session.PostBackspace(); } Assert.Null(session.OpeningPoint); Assert.Null(session.ClosingPoint); }
private void Format(IBraceCompletionSession session) { var buffer = session.SubjectBuffer; EditFilter.ApplyEdits( buffer, Formatter.GetEditsAfterEnter( buffer.CurrentSnapshot.GetText(), session.OpeningPoint.GetPosition(buffer.CurrentSnapshot), session.ClosingPoint.GetPosition(buffer.CurrentSnapshot), EditFilter.CreateFormattingOptions(session.TextView.Options, session.TextView.TextSnapshot) ) ); }
public virtual bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var position = session.OpeningPoint.GetPosition(snapshot); var token = snapshot.FindToken(position, cancellationToken); if (!IsValidToken(token)) { return false; } return token.RawKind == OpeningTokenKind && token.SpanStart == position; }
protected bool CheckClosingTokenKind(IBraceCompletionSession session, CancellationToken cancellationToken) { var document = session.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { var root = document.GetSyntaxRootSynchronously(cancellationToken); var position = session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot); return root.FindTokenFromEnd(position, includeZeroWidth: false, findInsideTrivia: true).RawKind == this.ClosingTokenKind; } return true; }
protected bool CheckCurrentPosition(IBraceCompletionSession session, CancellationToken cancellationToken) { var document = session.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { // make sure auto closing is called from a valid position var tree = document.GetSyntaxRootSynchronously(cancellationToken).SyntaxTree; return !_syntaxFactsService.IsInNonUserCode(tree, session.GetCaretPosition().Value, cancellationToken); } return true; }
internal void CheckStart(IBraceCompletionSession session, bool expectValidSession = true) { Type(session, session.OpeningBrace.ToString()); session.Start(); if (expectValidSession) { var closingPoint = session.ClosingPoint.GetPoint(session.SubjectBuffer.CurrentSnapshot).Subtract(1); Assert.Equal(closingPoint.GetChar(), session.ClosingBrace); } else { Assert.Null(session.OpeningPoint); Assert.Null(session.ClosingPoint); } }
public override bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var position = session.OpeningPoint.GetPosition(snapshot); var token = snapshot.FindToken(position, cancellationToken); // check what parser thinks about the newly typed "<" and only proceed if parser thinks it is "<" of // type argument or parameter list if (!token.CheckParent<TypeParameterListSyntax>(n => n.LessThanToken == token) && !token.CheckParent<TypeArgumentListSyntax>(n => n.LessThanToken == token) && !PossibleTypeArgument(snapshot, token, cancellationToken)) { return false; } return true; }
public override bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var position = session.OpeningPoint.GetPosition(snapshot); var token = snapshot.FindToken(position, cancellationToken); if (!IsValidToken(token) || token.RawKind != OpeningTokenKind) { return false; } if (token.SpanStart == position) { return true; } return token.SpanStart + 1 == position && snapshot[token.SpanStart] == VerbatimStringPrefix; }
internal void CheckTab(IBraceCompletionSession session, bool allowTab = true) { session.PreTab(out var handled); if (!handled) { session.PostTab(); } var caret = session.TextView.GetCaretPoint(session.SubjectBuffer).Value; if (allowTab) { Assert.Equal(session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot), caret.Position); } else { Assert.True(caret.Position < session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot)); } }
internal void CheckReturn(IBraceCompletionSession session, int indentation, string result = null) { session.PreReturn(out var handled); Type(session, Environment.NewLine); if (!handled) { session.PostReturn(); } var virtualCaret = session.TextView.GetVirtualCaretPoint(session.SubjectBuffer).Value; Assert.Equal(indentation, virtualCaret.VirtualSpaces); if (result != null) { Assert.Equal(result, session.SubjectBuffer.CurrentSnapshot.GetText()); } }
public void OnReturn(IBraceCompletionSession session) { // check whether shape of the braces are what we support // shape must be either "{|}" or "{ }". | is where caret is. otherwise, we don't do any special behavior if (!ContainsOnlyWhitespace(session)) return; // alright, it is in right shape. var undoHistory = GetUndoHistory(session.TextView); using (var transaction = undoHistory.CreateTransaction("Brace completion")) { session.SubjectBuffer.Insert(session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot) - 1, Environment.NewLine); FormatTrackingSpan(session, false); // put caret at right indentation PutCaretOnLine(session, session.OpeningPoint.GetPoint(session.SubjectBuffer.CurrentSnapshot).GetContainingLine().LineNumber + 1); transaction.Complete(); } }
private bool IsOpeningBraceOfType(IBraceCompletionSession session) { var snapshot = session.SubjectBuffer.CurrentSnapshot; var startPoint = session.OpeningPoint.GetPoint(snapshot); var classifier = startPoint.Snapshot.TextBuffer.GetSyntaxTagger(); var snapshotSpan = new SnapshotSpan(startPoint - 1, 1); var classificationSpans = classifier .GetTags(new NormalizedSnapshotSpanCollection(snapshotSpan)) .Where(x => x.Span.Start < startPoint); foreach (var span in classificationSpans.Reverse()) { if (span.Tag.ClassificationType.IsOfType(_classificationService.WhiteSpace.Classification)) continue; if (span.Tag.ClassificationType.IsOfType(_classificationService.Identifier.Classification)) continue; if (span.Tag.ClassificationType.IsOfType(_classificationService.Keyword.Classification)) { switch (span.Span.GetText()) { case "class": case "struct": case "interface": case "cbuffer": return true; default: return false; } } return false; } return false; }
internal static void CheckText(IBraceCompletionSession session, string result) => Assert.Equal(result, session.SubjectBuffer.CurrentSnapshot.GetText());
public Holder(TestWorkspace workspace, IBraceCompletionSession session) { this.Workspace = workspace; this.Session = session; }
public bool AllowOverType(IBraceCompletionSession session, CancellationToken cancellationToken) { return true; }
public static SnapshotPoint?GetCaretPosition(this IBraceCompletionSession session) { return(GetCaretPoint(session, session.SubjectBuffer)); }
// get the caret position within the given buffer private static SnapshotPoint?GetCaretPoint(this IBraceCompletionSession session, ITextBuffer buffer) { return(session.TextView.Caret.Position.Point.GetPoint(buffer, PositionAffinity.Predecessor)); }
public void Start(IBraceCompletionSession session) { // If user has just typed opening brace of a type, then (depending on user settings) add a semicolon after the close brace. if (session.OpeningBrace == BraceKind.CurlyBrackets.Open && _optionsService.AdvancedOptions.AddSemicolonForTypes && IsOpeningBraceOfType(session)) session.SubjectBuffer.Insert(session.ClosingPoint.GetPosition(session.SubjectBuffer.CurrentSnapshot), ";"); }
public override bool AllowOverType(IBraceCompletionSession session, CancellationToken cancellationToken) { return CheckCurrentPosition(session, cancellationToken); }
public static SnapshotPoint?GetCaretPosition(this IBraceCompletionSession session) { return(session.TextView.Caret.Position.Point.GetPoint(session.SubjectBuffer, PositionAffinity.Successor)); }
public void AfterStart(IBraceCompletionSession session, CancellationToken cancellationToken) { }
public void Finish(IBraceCompletionSession session) { }
public bool TryCreateSession(ITextView textView, SnapshotPoint openingPoint, char openingBrace, char closingBrace, out IBraceCompletionSession session) { _threadingContext.ThrowIfNotOnUIThread(); var textSnapshot = openingPoint.Snapshot; var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { var editorSessionFactory = document.GetLanguageService <IBraceCompletionServiceFactory>(); if (editorSessionFactory != null) { // Brace completion is (currently) not cancellable. var cancellationToken = CancellationToken.None; var editorSession = editorSessionFactory.TryGetServiceAsync(document, openingPoint, openingBrace, cancellationToken).WaitAndGetResult(cancellationToken); if (editorSession != null) { var undoHistory = _undoManager.GetTextBufferUndoManager(textView.TextBuffer).TextBufferUndoHistory; session = new BraceCompletionSession( textView, openingPoint.Snapshot.TextBuffer, openingPoint, openingBrace, closingBrace, undoHistory, _editorOperationsFactoryService, editorSession, _globalOptions, _threadingContext); return(true); } } } session = null; return(false); }
public override bool AllowOverType(IBraceCompletionSession session, CancellationToken cancellationToken) { return(CheckCurrentPosition(session, cancellationToken)); }
public bool CheckOpeningPoint(IBraceCompletionSession session, CancellationToken cancellationToken) { return true; }
public override void AfterStart(IBraceCompletionSession session, CancellationToken cancellationToken) { FormatTrackingSpan(session, shouldHonorAutoFormattingOnCloseBraceOption: true); //session.TryMoveCaret(session.ClosingPoint - 1); }
private void PutCaretOnLine(IBraceCompletionSession session, int lineNumber) { var lineOnSubjectBuffer = session.SubjectBuffer.CurrentSnapshot.GetLineFromLineNumber(lineNumber); var indentation = GetDesiredIndentation(session, lineOnSubjectBuffer); session.TextView.TryMoveCaretToAndEnsureVisible(new VirtualSnapshotPoint(lineOnSubjectBuffer, indentation)); }
public bool TryCreateSession(ITextView textView, SnapshotPoint openingPoint, char openingBrace, char closingBrace, out IBraceCompletionSession session) { this.AssertIsForeground(); var textSnapshot = openingPoint.Snapshot; var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { var editorSessionFactory = document.GetLanguageService <IEditorBraceCompletionSessionFactory>(); if (editorSessionFactory != null) { // Brace completion is (currently) not cancellable. var cancellationToken = CancellationToken.None; var editorSession = editorSessionFactory.TryCreateSession(document, openingPoint, openingBrace, cancellationToken); if (editorSession != null) { var undoHistory = _undoManager.GetTextBufferUndoManager(textView.TextBuffer).TextBufferUndoHistory; session = new BraceCompletionSession( textView, openingPoint.Snapshot.TextBuffer, openingPoint, openingBrace, closingBrace, undoHistory, _editorOperationsFactoryService, editorSession); return(true); } } } session = null; return(false); }
public override void AfterStart(IBraceCompletionSession session, CancellationToken cancellationToken) { FormatTrackingSpan(session, shouldHonorAutoFormattingOnCloseBraceOption: true); session.TextView.TryMoveCaretToAndEnsureVisible(session.ClosingPoint.GetPoint(session.SubjectBuffer.CurrentSnapshot).Subtract(1)); }
public virtual bool AllowOverType(IBraceCompletionSession session, CancellationToken cancellationToken) { return(CheckCurrentPosition(session, cancellationToken) && CheckClosingTokenKind(session, cancellationToken)); }
public override void Start(IBraceCompletionSession session) { base.LanguageInfo.TryFormat(session.GetSessionSpan()); }
public bool AllowOverType(IBraceCompletionSession session) { return true; }
/// <summary> /// Attempt to create a session using the provider that best matches the buffer content type for /// the given opening brace. This is called only for appropriate buffers in the view's buffer graph. /// </summary> public bool TryCreateSession(ITextView textView, SnapshotPoint openingPoint, char openingBrace, out IBraceCompletionSession session) { ITextBuffer buffer = openingPoint.Snapshot.TextBuffer; IContentType bufferContentType = buffer.ContentType; List <IContentType> contentTypes; if (_contentTypeCache.TryGetValue(openingBrace, out contentTypes)) { foreach (IContentType providerContentType in contentTypes) { // find a matching content type if (bufferContentType.IsOfType(providerContentType.TypeName)) { // try all providers for that type List <ProviderHelper> providersForBrace; if (_providerCache[openingBrace].TryGetValue(providerContentType, out providersForBrace)) { foreach (ProviderHelper provider in providersForBrace) { IBraceCompletionSession curSession = null; if (provider.TryCreate(_factory, textView, openingPoint, openingBrace, out curSession)) { session = curSession; return(true); } } } // only try the best match break; } } } session = null; return(false); }
public void AfterReturn(IBraceCompletionSession session, CancellationToken cancellationToken) { }
public override bool AllowOverType(IBraceCompletionSession session, CancellationToken cancellationToken) { return(true); }
public void Start(IBraceCompletionSession session) { }
private void FormatTrackingSpan(IBraceCompletionSession session, bool shouldHonorAutoFormattingOnCloseBraceOption, IEnumerable<IFormattingRule> rules = null) { if (!session.SubjectBuffer.GetFeatureOnOffOption(FeatureOnOffOptions.AutoFormattingOnCloseBrace) && shouldHonorAutoFormattingOnCloseBraceOption) { return; } var snapshot = session.SubjectBuffer.CurrentSnapshot; var startPoint = session.OpeningPoint.GetPoint(snapshot); var endPoint = session.ClosingPoint.GetPoint(snapshot); var startPosition = startPoint.Position; var endPosition = endPoint.Position; // Do not format within the braces if they're on the same line for array/collection/object initializer expressions. // This is a heuristic to prevent brace completion from breaking user expectation/muscle memory in common scenarios. // see bug Devdiv:823958 if (startPoint.GetContainingLineNumber() == endPoint.GetContainingLineNumber()) { // Brace completion is not cancellable var startToken = snapshot.FindToken(startPosition, CancellationToken.None); if (startToken.IsKind(SyntaxKind.OpenBraceToken) && (startToken.Parent.IsInitializerForArrayOrCollectionCreationExpression() || startToken.Parent is AnonymousObjectCreationExpressionSyntax)) { // format everything but the brace pair. var endToken = snapshot.FindToken(endPosition, CancellationToken.None); if (endToken.IsKind(SyntaxKind.CloseBraceToken)) { endPosition = endPosition - (endToken.Span.Length + startToken.Span.Length); } } } var document = snapshot.GetOpenDocumentInCurrentContextWithChanges(); var style = document != null ? document.GetOptionsAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None).GetOption(SmartIndent) : SmartIndent.DefaultValue; if (style == IndentStyle.Smart) { // skip whitespace while (startPosition >= 0 && char.IsWhiteSpace(snapshot[startPosition])) { startPosition--; } // skip token startPosition--; while (startPosition >= 0 && !char.IsWhiteSpace(snapshot[startPosition])) { startPosition--; } } session.SubjectBuffer.Format(TextSpan.FromBounds(Math.Max(startPosition, 0), endPosition), rules); }
public bool AllowOverType(IBraceCompletionSession session) { return(true); }
private int GetDesiredIndentation(IBraceCompletionSession session, ITextSnapshotLine lineOnSubjectBuffer) { // first try VS's smart indentation service var indentation = session.TextView.GetDesiredIndentation(_smartIndentationService, lineOnSubjectBuffer); if (indentation.HasValue) { return indentation.Value; } // do poor man's indentation var openingPoint = session.OpeningPoint.GetPoint(lineOnSubjectBuffer.Snapshot); var openingSpanLine = openingPoint.GetContainingLine(); return openingPoint - openingSpanLine.Start; }
private void PutCaretOnLine(IBraceCompletionSession session, SourceText text, TextLine line) { var indentation = GetDesiredIndentation(session, text); session.TryMoveCaret(line.Start + indentation); }
public void OnReturn(IBraceCompletionSession session) { }
// Create the session public bool TryCreate(BraceCompletionAggregatorFactory factory, ITextView textView, SnapshotPoint openingPoint, char openingBrace, out IBraceCompletionSession session) { char closingBrace = GetClosingBrace(Metadata, openingBrace); if (IsSession) { bool created = false; IBraceCompletionSession currentSession = null; factory.GuardedOperations.CallExtensionPoint(() => { created = _sessionPair.Value.TryCreateSession(textView, openingPoint, openingBrace, closingBrace, out currentSession); }); if (created) { session = currentSession; return(true); } session = null; return(false); } else if (IsContext) { // Get a language specific context and add it to a default session. IBraceCompletionContext context = null; // check AllowDefaultSession to avoid starting a new "" session next to a " if (AllowDefaultSession(openingPoint, openingBrace, closingBrace)) { bool created = false; factory.GuardedOperations.CallExtensionPoint(() => { created = _contextPair.Value.TryCreateContext(textView, openingPoint, openingBrace, closingBrace, out context); }); if (created) { session = new BraceCompletionDefaultSession(textView, openingPoint.Snapshot.TextBuffer, openingPoint, openingBrace, closingBrace, factory.UndoManager, factory.EditorOperationsFactoryService, context); return(true); } } session = null; return(false); } else if (IsDefault) { // perform some basic checks on the buffer before going in if (AllowDefaultSession(openingPoint, openingBrace, closingBrace)) { session = new BraceCompletionDefaultSession(textView, openingPoint.Snapshot.TextBuffer, openingPoint, openingBrace, closingBrace, factory.UndoManager, factory.EditorOperationsFactoryService); return(true); } } session = null; return(false); }
/// <summary> /// Called by the editor when the closing brace character has been typed. /// </summary> /// <remarks> /// The closing brace character will not be inserted into the buffer /// until after this returns. Does not occur if there is any non-whitespace /// between the caret and the closing brace. Language-specific decisions /// may be made here to take into account scenarios such as an escaped /// closing char. /// </remarks> /// <param name="session">Default brace completion session</param> /// <returns>Returns true if the context is a valid overtype scenario.</returns> public bool AllowOverType(IBraceCompletionSession session) => true;