private void SendUnableToUpdateRuleSetNotification(Workspace workspace, string message)
{
SendErrorNotification(
workspace,
SolutionExplorerShim.The_rule_set_file_could_not_be_updated,
message);
}
public static async Task <Stream> RequestServiceAsync(
Workspace workspace,
HubClient client,
string serviceName,
HostGroup hostGroup,
CancellationToken cancellationToken)
{
var descriptor = new ServiceDescriptor(serviceName)
{
HostGroup = hostGroup
};
try
{
return(await client.RequestServiceAsync(descriptor, cancellationToken).ConfigureAwait(false));
}
catch (Exception e) when(ReportNonFatalWatson(e, cancellationToken))
{
// TODO: Once https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1040692.
// ServiceHub may throw non-cancellation exceptions if it is called after VS started to shut down,
// even if our cancellation token is signaled. Cancel the operation and do not report an error in these cases.
//
// If ServiceHub did not throw non-cancellation exceptions when cancellation token is signaled,
// we can assume that these exceptions indicate a failure and should be reported to the user.
cancellationToken.ThrowIfCancellationRequested();
RemoteHostCrashInfoBar.ShowInfoBar(workspace, e);
// TODO: Propagate the original exception (see https://github.com/dotnet/roslyn/issues/40476)
throw new SoftCrashException("Unexpected exception from HubClient", e, cancellationToken);
}
public RemoteHostClientService(Workspace workspace, IDiagnosticAnalyzerService analyzerService)
{
_gate = new object();
_workspace = workspace;
_analyzerService = analyzerService;
}
public bool TryGetTextUndoHistory(Workspace editorWorkspace, ITextBuffer textBuffer, out ITextUndoHistory undoHistory)
{
undoHistory = null;
if (!(editorWorkspace is VisualStudioWorkspaceImpl) &&
!(editorWorkspace is MiscellaneousFilesWorkspace))
{
return false;
}
// TODO: Handle undo if context changes
var documentId = editorWorkspace.GetDocumentIdInCurrentContext(textBuffer.AsTextContainer());
if (documentId == null)
{
return false;
}
var document = GetDocument(editorWorkspace, documentId);
if (document == null)
{
return false;
}
undoHistory = document.GetTextUndoHistory();
return true;
}
private IndentationOptions(Workspace workspace)
{
var options = workspace.Options;
this.IndentationSize = options.GetOption(FormattingOptions.IndentationSize, LanguageNames.CSharp);
this.TabSize = options.GetOption(FormattingOptions.TabSize, LanguageNames.CSharp);
this.UseTabs = options.GetOption(FormattingOptions.UseTabs, LanguageNames.CSharp);
}
public static void Enable(Workspace workspace, Options options)
{
var service = workspace.Services.GetService<ISolutionCrawlerRegistrationService>();
workspace.Options = GetOptions(workspace, options);
service.Register(workspace);
}
protected AbstractTable(Workspace workspace, ITableManagerProvider provider, string tableIdentifier)
{
_workspace = workspace;
_provider = provider;
this.TableManager = provider.GetTableManager(tableIdentifier);
}
private SourceReferenceTreeItem(
Document document, TextSpan sourceSpan, ushort glyphIndex, int commonPathElements)
: base(glyphIndex)
{
// We store the document ID, line and offset for navigation so that we
// still provide reasonable navigation if the user makes changes elsewhere
// in the document other than inserting or removing lines.
_workspace = document.Project.Solution.Workspace;
_documentId = document.Id;
_projectName = document.Project.Name;
_filePath = GetFilePath(document, commonPathElements);
_sourceSpan = sourceSpan;
var text = document.GetTextAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
var textLine = text.Lines.GetLineFromPosition(_sourceSpan.Start);
_textLineString = textLine.ToString();
_lineNumber = textLine.LineNumber;
_offset = sourceSpan.Start - textLine.Start;
var spanInSecondaryBuffer = text.GetVsTextSpanForLineOffset(_lineNumber, _offset);
var succeeded = spanInSecondaryBuffer.TryMapSpanFromSecondaryBufferToPrimaryBuffer(_workspace, _documentId, out var spanInPrimaryBuffer);
_mappedLineNumber = succeeded ? spanInPrimaryBuffer.iStartLine : _lineNumber;
_mappedOffset = succeeded ? spanInPrimaryBuffer.iStartIndex : _offset;
}
public IList<TextChange> FormatToken(Workspace workspace, SyntaxToken token, CancellationToken cancellationToken)
{
Contract.ThrowIfTrue(token.Kind() == SyntaxKind.None || token.Kind() == SyntaxKind.EndOfFileToken);
// get previous token
var previousToken = token.GetPreviousToken(includeZeroWidth: true);
if (previousToken.Kind() == SyntaxKind.None)
{
// no previous token. nothing to format
return SpecializedCollections.EmptyList<TextChange>();
}
// This is a heuristic to prevent brace completion from breaking user expectation/muscle memory in common scenarios (see Devdiv:823958).
// Formatter uses FindToken on the position, which returns token to left, if there is nothing to the right and returns token to the right
// if there exists one. If the shape is "{|}", we're including '}' in the formatting range. Avoid doing that to improve verbatim typing
// in the following special scenarios.
int adjustedEndPosition = token.Span.End;
if (token.IsKind(SyntaxKind.OpenBraceToken) &&
(token.Parent.IsInitializerForArrayOrCollectionCreationExpression() ||
token.Parent is AnonymousObjectCreationExpressionSyntax))
{
var nextToken = token.GetNextToken(includeZeroWidth: true);
if (nextToken.IsKind(SyntaxKind.CloseBraceToken))
{
// Format upto '{' and exclude '}'
adjustedEndPosition = token.SpanStart;
}
}
var smartTokenformattingRules = (new SmartTokenFormattingRule()).Concat(_formattingRules);
return Formatter.GetFormattedTextChanges(_root, new TextSpan[] { TextSpan.FromBounds(previousToken.SpanStart, adjustedEndPosition) }, workspace, _optionSet, smartTokenformattingRules, cancellationToken);
}
public static async Task <RemoteHostClient> CreateAsync(
Workspace workspace, CancellationToken cancellationToken)
{
try
{
using (Logger.LogBlock(FunctionId.ServiceHubRemoteHostClient_CreateAsync, cancellationToken))
{
var primary = new HubClient("ManagedLanguage.IDE.RemoteHostClient");
var timeout = TimeSpan.FromMilliseconds(workspace.Options.GetOption(RemoteHostOptions.RequestServiceTimeoutInMS));
// Retry (with timeout) until we can connect to RemoteHost (service hub process).
// we are seeing cases where we failed to connect to service hub process when a machine is under heavy load.
// (see https://devdiv.visualstudio.com/DevDiv/_workitems/edit/481103 as one of example)
var instance = await Connections.RetryRemoteCallAsync <IOException, ServiceHubRemoteHostClient>(
workspace, () => CreateWorkerAsync(workspace, primary, timeout, cancellationToken), timeout, cancellationToken).ConfigureAwait(false);
instance.Started();
// return instance
return(instance);
}
}
catch (SoftCrashException)
{
// at this point, we should have shown info bar (RemoteHostCrashInfoBar.ShowInfoBar) to users
// returning null here will disable OOP for this VS session.
// * Note * this is not trying to recover the exception. but giving users to time
// to clean up before restart VS
return(null);
}
}
public override void Apply(Microsoft.CodeAnalysis.Workspace workspace, CancellationToken cancellationToken = default)
{
var visualStudioWorkspace = (VisualStudioWorkspaceImpl)workspace;
if (!visualStudioWorkspace.TryAddReferenceToProject(_projectId, "*" + _assemblyIdentity.GetDisplayName()))
{
// We failed to add the reference, which means the project system wasn't able to bind.
// We'll pop up the Add Reference dialog to let the user figure this out themselves.
// This is the same approach done in CVBErrorFixApply::ApplyAddMetaReferenceFix
if (visualStudioWorkspace.GetHierarchy(_projectId) is IVsUIHierarchy uiHierarchy)
{
var command = new OLECMD[1];
command[0].cmdID = (uint)VSConstants.VSStd2KCmdID.ADDREFERENCE;
if (ErrorHandler.Succeeded(uiHierarchy.QueryStatusCommand((uint)VSConstants.VSITEMID.Root, VSConstants.VSStd2K, 1, command, IntPtr.Zero)))
{
if ((((OLECMDF)command[0].cmdf) & OLECMDF.OLECMDF_ENABLED) != 0)
{
uiHierarchy.ExecCommand((uint)VSConstants.VSITEMID.Root, VSConstants.VSStd2K, (uint)VSConstants.VSStd2KCmdID.ADDREFERENCE, 0, IntPtr.Zero, IntPtr.Zero);
}
}
}
}
}
/// <summary>
/// Load a text and a version of the document in the workspace.
/// </summary>
/// <exception cref="IOException"></exception>
public override async Task<TextAndVersion> LoadTextAndVersionAsync(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken)
{
DateTime prevLastWriteTime = FileUtilities.GetFileTimeStamp(_path);
TextAndVersion textAndVersion;
// Open file for reading with FileShare mode read/write/delete so that we do not lock this file.
using (var stream = FileUtilities.RethrowExceptionsAsIOException(() => new FileStream(_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete, bufferSize: 4096, useAsync: true)))
{
var version = VersionStamp.Create(prevLastWriteTime);
// we do this so that we asynchronously read from file. and this should allocate less for IDE case.
// but probably not for command line case where it doesn't use more sophisticated services.
using (var readStream = await SerializableBytes.CreateReadableStreamAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false))
{
var text = CreateText(readStream, workspace);
textAndVersion = TextAndVersion.Create(text, version, _path);
}
}
// Check if the file was definitely modified and closed while we were reading. In this case, we know the read we got was
// probably invalid, so throw an IOException which indicates to our caller that we should automatically attempt a re-read.
// If the file hasn't been closed yet and there's another writer, we will rely on file change notifications to notify us
// and reload the file.
DateTime newLastWriteTime = FileUtilities.GetFileTimeStamp(_path);
if (!newLastWriteTime.Equals(prevLastWriteTime))
{
var message = string.Format(WorkspacesResources.File_was_externally_modified_colon_0, _path);
throw new IOException(message);
}
return textAndVersion;
}
internal /*for testing purposes*/ SonarAnalyzerManager(IServiceProvider serviceProvider, Workspace workspace,
ISolutionAnalysisRequester solutionAnalysisRequester)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
this.workspace = workspace;
this.activeSolutionBoundTracker = serviceProvider.GetMefService<IActiveSolutionBoundTracker>();
if (this.activeSolutionBoundTracker == null)
{
Debug.Fail($"Could not get {nameof(IActiveSolutionBoundTracker)}");
}
this.solutionAnalysisRequester = solutionAnalysisRequester;
this.activeSolutionBoundTracker.SolutionBindingChanged += this.ActiveSolutionBoundTracker_SolutionBindingChanged;
SonarAnalysisContext.ShouldAnalysisBeDisabled =
tree => ShouldAnalysisBeDisabledOnTree(tree);
}
private static MemberDeclarationSyntax GenerateBackingField(ITypeSymbol typeSymbol, string backingFieldName, Workspace workspace)
{
var generator = SyntaxGenerator.GetGenerator(workspace, LanguageNames.CSharp);
SyntaxNode type = generator.TypeExpression(typeSymbol);
FieldDeclarationSyntax fieldDecl = ParseMember($"private _field_Type_ {backingFieldName};") as FieldDeclarationSyntax;
return fieldDecl.ReplaceNode(fieldDecl.Declaration.Type, type.WithAdditionalAnnotations(Simplifier.SpecialTypeAnnotation));
}
public static IEnumerable<ClassifiedSpan> GetClassifiedSpans(
SemanticModel semanticModel,
TextSpan textSpan,
Workspace workspace,
CancellationToken cancellationToken = default(CancellationToken))
{
var service = workspace.Services.GetLanguageServices(semanticModel.Language).GetService<IClassificationService>();
var syntaxClassifiers = service.GetDefaultSyntaxClassifiers();
var extensionManager = workspace.GetExtensionManager();
var getNodeClassifiers = extensionManager.CreateNodeExtensionGetter(syntaxClassifiers, c => c.SyntaxNodeTypes);
var getTokenClassifiers = extensionManager.CreateTokenExtensionGetter(syntaxClassifiers, c => c.SyntaxTokenKinds);
var syntacticClassifications = new List<ClassifiedSpan>();
var semanticClassifications = new List<ClassifiedSpan>();
service.AddSyntacticClassifications(semanticModel.SyntaxTree, textSpan, syntacticClassifications, cancellationToken);
service.AddSemanticClassifications(semanticModel, textSpan, workspace, getNodeClassifiers, getTokenClassifiers, semanticClassifications, cancellationToken);
var allClassifications = new List<ClassifiedSpan>(semanticClassifications.Where(s => s.TextSpan.OverlapsWith(textSpan)));
var semanticSet = semanticClassifications.Select(s => s.TextSpan).ToSet();
allClassifications.AddRange(syntacticClassifications.Where(
s => s.TextSpan.OverlapsWith(textSpan) && !semanticSet.Contains(s.TextSpan)));
allClassifications.Sort((s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start);
return allClassifications;
}
/// <summary>
/// For testing purposes only.
/// </summary>
internal SymbolSearchService(
Workspace workspace,
IPackageInstallerService installerService,
IRemoteControlService remoteControlService,
ILogService logService,
IDelayService delayService,
IIOService ioService,
IPatchService patchService,
IDatabaseFactoryService databaseFactoryService,
string localSettingsDirectory,
Func<Exception, bool> reportAndSwallowException,
CancellationTokenSource cancellationTokenSource)
{
if (remoteControlService == null)
{
// If we can't access the file update service, then there's nothing we can do.
return;
}
_workspace = workspace;
_installerService = installerService;
_delayService = delayService;
_ioService = ioService;
_logService = logService;
_remoteControlService = remoteControlService;
_patchService = patchService;
_databaseFactoryService = databaseFactoryService;
_localSettingsDirectory = localSettingsDirectory;
_reportAndSwallowException = reportAndSwallowException;
_cancellationTokenSource = cancellationTokenSource;
_cancellationToken = _cancellationTokenSource.Token;
}
public override async Task<TextAndVersion> LoadTextAndVersionAsync(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken)
{
DateTime prevLastWriteTime = File.GetLastWriteTimeUtc(this.path);
// Open file for reading with FileShare mode read/write/delete so that we do not lock this file.
// Allowing other theads/processes to write or delete the file is essential for scenarios such as
// Rename refactoring where File.Replace API is invoked for updating the modified file.
TextAndVersion textAndVersion;
using (var stream = File.Open(this.path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete))
{
var version = VersionStamp.Create(prevLastWriteTime);
var memoryStream = await this.ReadStreamAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false);
var text = CreateText(memoryStream, workspace);
textAndVersion = TextAndVersion.Create(text, version, path);
}
// this has a potential to return corrupted state text if someone changed text in the middle of us reading it.
// previously, we attempted to detect such case and return empty string with workspace failed event.
// but that is nothing better or even worse than returning what we have read so far.
//
// I am letting it to return what we have read so far. and hopefully, file change event let us re-read this file.
// (* but again, there is still a chance where file change event happens even before writing has finished which ends up
// let us stay in corrupted state)
DateTime newLastWriteTime = File.GetLastWriteTimeUtc(this.path);
if (!newLastWriteTime.Equals(prevLastWriteTime))
{
// TODO: remove this once we know how often this can happen.
// I am leaving this here for now for diagnostic purpose.
var message = string.Format(WorkspacesResources.FileWasExternallyModified, this.path);
workspace.OnWorkspaceFailed(new DocumentDiagnostic(WorkspaceDiagnosticKind.FileAccessFailure, message, documentId));
}
return textAndVersion;
}
private MiscellaneousDiagnosticListTable(
SVsServiceProvider serviceProvider, Workspace workspace, IDiagnosticService diagnosticService, ITableManagerProvider provider) :
base(serviceProvider, workspace, diagnosticService, provider)
{
_source = new LiveTableDataSource(serviceProvider, workspace, diagnosticService, IdentifierString);
AddInitialTableSource(workspace.CurrentSolution, _source);
}
public SourceListItem(Document document, TextSpan sourceSpan, ushort glyphIndex)
: base(glyphIndex)
{
_workspace = document.Project.Solution.Workspace;
// We store the document ID, line and offset for navigation so that we
// still provide reasonable navigation if the user makes changes elsewhere
// in the document other than inserting or removing lines.
_documentId = document.Id;
var filePath = document.FilePath;
var text = document.GetTextAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
var textLine = text.Lines.GetLineFromPosition(sourceSpan.Start);
_lineNumber = textLine.LineNumber;
_offset = sourceSpan.Start - textLine.Start;
var spanInSecondaryBuffer = text.GetVsTextSpanForLineOffset(_lineNumber, _offset);
VsTextSpan spanInPrimaryBuffer;
var succeeded = spanInSecondaryBuffer.TryMapSpanFromSecondaryBufferToPrimaryBuffer(_workspace, document.Id, out spanInPrimaryBuffer);
var mappedLineNumber = succeeded ? spanInPrimaryBuffer.iStartLine : _lineNumber;
var mappedOffset = succeeded ? spanInPrimaryBuffer.iStartIndex : _offset;
SetDisplayProperties(filePath, mappedLineNumber, mappedOffset, _lineNumber, _offset, textLine.ToString(), sourceSpan.Length);
}
public bool TryOnAfterGlobalSymbolRenamed(Workspace workspace, IEnumerable<DocumentId> changedDocumentIDs, ISymbol symbol, string newName, bool throwOnFailure)
{
var visualStudioWorkspace = workspace as VisualStudioWorkspaceImpl;
if (visualStudioWorkspace != null)
{
foreach (var documentId in changedDocumentIDs)
{
var containedDocument = visualStudioWorkspace.GetHostDocument(documentId) as ContainedDocument;
if (containedDocument != null)
{
var containedLanguageHost = containedDocument.ContainedLanguage.ContainedLanguageHost;
if (containedLanguageHost != null)
{
var hresult = containedLanguageHost.OnRenamed(
GetRenameType(symbol), symbol.ToDisplayString(s_qualifiedDisplayFormat), newName);
if (hresult < 0)
{
if (throwOnFailure)
{
Marshal.ThrowExceptionForHR(hresult);
}
else
{
return false;
}
}
}
}
}
}
return true;
}
public SolutionServices(Workspace workspace)
{
this.Workspace = workspace;
this.TemporaryStorage = workspace.Services.GetService<ITemporaryStorageService>();
this.MetadataService = workspace.Services.GetService<IMetadataService>();
this.CacheService = workspace.Services.GetService<IProjectCacheHostService>();
}
internal static void LogSession(Workspace workspace, LinkedFileDiffMergingSessionInfo sessionInfo)
{
if (sessionInfo.LinkedFileGroups.Count > 1)
{
LogNewSessionWithLinkedFiles();
LogNumberOfLinkedFileGroupsProcessed(sessionInfo.LinkedFileGroups.Count);
foreach (var groupInfo in sessionInfo.LinkedFileGroups)
{
LogNumberOfIdenticalDiffs(groupInfo.IdenticalDiffs);
LogNumberOfIsolatedDiffs(groupInfo.IsolatedDiffs);
LogNumberOfOverlappingDistinctDiffs(groupInfo.OverlappingDistinctDiffs);
LogNumberOfOverlappingDistinctDiffsWithSameSpan(groupInfo.OverlappingDistinctDiffsWithSameSpan);
LogNumberOfOverlappingDistinctDiffsWithSameSpanAndSubstringRelation(groupInfo.OverlappingDistinctDiffsWithSameSpanAndSubstringRelation);
LogNumberOfInsertedMergeConflictComments(groupInfo.InsertedMergeConflictComments);
LogNumberOfInsertedMergeConflictCommentsAtAdjustedLocation(groupInfo.InsertedMergeConflictCommentsAtAdjustedLocation);
if (groupInfo.InsertedMergeConflictComments > 0 ||
groupInfo.InsertedMergeConflictCommentsAtAdjustedLocation > 0)
{
Logger.Log(FunctionId.Workspace_Solution_LinkedFileDiffMergingSession_LinkedFileGroup, SessionLogMessage.Create(groupInfo));
}
}
}
}
public static bool TryMapSpanFromSecondaryBufferToPrimaryBuffer(
this VsTextSpan spanInSecondaryBuffer,
Microsoft.CodeAnalysis.Workspace workspace,
DocumentId documentId,
out VsTextSpan spanInPrimaryBuffer
)
{
spanInPrimaryBuffer = default;
if (!(workspace is VisualStudioWorkspaceImpl visualStudioWorkspace))
{
return(false);
}
var containedDocument = visualStudioWorkspace.TryGetContainedDocument(documentId);
if (containedDocument == null)
{
return(false);
}
var bufferCoordinator = containedDocument.BufferCoordinator;
var primary = new VsTextSpan[1];
var hresult = bufferCoordinator.MapSecondaryToPrimarySpan(
spanInSecondaryBuffer,
primary
);
spanInPrimaryBuffer = primary[0];
return(ErrorHandler.Succeeded(hresult));
}
public static bool TryMapSpanFromSecondaryBufferToPrimaryBuffer(this VsTextSpan spanInSecondaryBuffer, Workspace workspace, DocumentId documentId, out VsTextSpan spanInPrimaryBuffer)
{
spanInPrimaryBuffer = default(VsTextSpan);
var visualStudioWorkspace = workspace as VisualStudioWorkspaceImpl;
if (visualStudioWorkspace == null)
{
return false;
}
var containedDocument = visualStudioWorkspace.GetHostDocument(documentId) as ContainedDocument;
if (containedDocument == null)
{
return false;
}
var bufferCoordinator = containedDocument.ContainedLanguage.BufferCoordinator;
var primary = new VsTextSpan[1];
var hresult = bufferCoordinator.MapSecondaryToPrimarySpan(spanInSecondaryBuffer, primary);
spanInPrimaryBuffer = primary[0];
return ErrorHandler.Succeeded(hresult);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompilationContext"/> class.
/// </summary>
public CompilationContext(Workspace workspace, Document currentDocument)
{
Workspace = workspace;
CurrentDocument = currentDocument;
DocumentEditor = DocumentEditor.CreateAsync(currentDocument).Result;
}
public static async Task<RemoteHostClient> CreateAsync(
Workspace workspace, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.ServiceHubRemoteHostClient_CreateAsync, cancellationToken))
{
var primary = new HubClient("ManagedLanguage.IDE.RemoteHostClient");
var remoteHostStream = await primary.RequestServiceAsync(WellKnownRemoteHostServices.RemoteHostService, cancellationToken).ConfigureAwait(false);
var instance = new ServiceHubRemoteHostClient(workspace, primary, remoteHostStream);
// make sure connection is done right
var current = $"VS ({Process.GetCurrentProcess().Id})";
var host = await instance._rpc.InvokeAsync<string>(WellKnownRemoteHostServices.RemoteHostService_Connect, current).ConfigureAwait(false);
// TODO: change this to non fatal watson and make VS to use inproc implementation
Contract.ThrowIfFalse(host == current.ToString());
instance.Connected();
// Create a workspace host to hear about workspace changes. We'll
// remote those changes over to the remote side when they happen.
RegisterWorkspaceHost(workspace, instance);
// return instance
return instance;
}
}
public static async Task<IEnumerable<LinePositionSpanTextChange>> GetFormattingChangesAfterKeystroke(Workspace workspace, OptionSet options, Document document, int position, char character)
{
var tree = await document.GetSyntaxTreeAsync();
if (character == '\n')
{
// format previous line on new line
var lines = (await document.GetTextAsync()).Lines;
var targetLine = lines[lines.GetLineFromPosition(position).LineNumber - 1];
if (!string.IsNullOrWhiteSpace(targetLine.Text.ToString(targetLine.Span)))
{
return await GetFormattingChangesForRange(workspace, options, document, targetLine.Start, targetLine.End);
}
}
else if (character == '}' || character == ';')
{
// format after ; and }
var node = FindFormatTarget(tree, position);
if (node != null)
{
return await GetFormattingChangesForRange(workspace, options, document, node.FullSpan.Start, node.FullSpan.End);
}
}
return Enumerable.Empty<LinePositionSpanTextChange>();
}
public AbstractSourceTreeItem(Document document, TextSpan sourceSpan, ushort glyphIndex, int commonPathElements = 0)
: base(glyphIndex)
{
// We store the document ID, line and offset for navigation so that we
// still provide reasonable navigation if the user makes changes elsewhere
// in the document other than inserting or removing lines.
_workspace = document.Project.Solution.Workspace;
_documentId = document.Id;
_projectName = document.Project.Name;
_filePath = GetFilePath(document, commonPathElements);
_sourceSpan = sourceSpan;
var text = document.GetTextAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
var textLine = text.Lines.GetLineFromPosition(_sourceSpan.Start);
_textLineString = textLine.ToString();
_lineNumber = textLine.LineNumber;
_offset = sourceSpan.Start - textLine.Start;
var spanInSecondaryBuffer = text.GetVsTextSpanForLineOffset(_lineNumber, _offset);
VsTextSpan spanInPrimaryBuffer;
var succeeded = spanInSecondaryBuffer.TryMapSpanFromSecondaryBufferToPrimaryBuffer(_workspace, _documentId, out spanInPrimaryBuffer);
_mappedLineNumber = succeeded ? spanInPrimaryBuffer.iStartLine : _lineNumber;
_mappedOffset = succeeded ? spanInPrimaryBuffer.iStartIndex : _offset;
}
/// <summary>
/// Register a workspace as the primary workspace. Only one workspace can be the primary.
/// </summary>
public static void Register(Workspace workspace)
{
if (workspace == null)
{
throw new ArgumentNullException("workspace");
}
using (s_registryGate.DisposableWrite())
{
s_primaryWorkspace = workspace;
foreach (var taskSource in s_primaryWorkspaceTaskSourceList)
{
try
{
taskSource.TrySetResult(workspace);
}
catch
{
}
}
s_primaryWorkspaceTaskSourceList.Clear();
}
}
public static IOleUndoManager TryGetUndoManager(
this IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
Microsoft.CodeAnalysis.Workspace workspace,
DocumentId contextDocumentId,
CancellationToken cancellationToken)
{
// https://github.com/dotnet/roslyn/issues/17898
// We have a report of a null ref occurring in this method. The only place we believe
// this could be would be if 'document' was null. Try to catch a reasonable
// non -fatal-watson dump to help track down what the root cause of this might be.
var document = workspace.CurrentSolution.GetDocument(contextDocumentId);
if (document == null)
{
var message = contextDocumentId == null
? $"{nameof(contextDocumentId)} was null."
: $"{nameof(contextDocumentId)} was not null.";
FatalError.ReportWithoutCrash(new InvalidOperationException("Could not retrieve document. " + message));
return(null);
}
var text = document.GetTextSynchronously(cancellationToken);
var textSnapshot = text.FindCorrespondingEditorTextSnapshot();
var textBuffer = textSnapshot?.TextBuffer;
return(editorAdaptersFactoryService.TryGetUndoManager(textBuffer));
}
public IList<string> GetFolders(ProjectId projectId, Workspace workspace)
{
var folders = new List<string>();
if (workspace is VisualStudioWorkspaceImpl)
{
((VisualStudioWorkspaceImpl)workspace).GetProjectData(projectId, out var ivisualStudioHostProject, out var hierarchy, out var envDTEProject);
var projectItems = envDTEProject.ProjectItems;
var projectItemsStack = new Stack<Tuple<ProjectItem, string>>();
// Populate the stack
projectItems.OfType<ProjectItem>().Where(n => n.IsFolder()).Do(n => projectItemsStack.Push(Tuple.Create(n, "\\")));
while (projectItemsStack.Count != 0)
{
var projectItemTuple = projectItemsStack.Pop();
var projectItem = projectItemTuple.Item1;
var currentFolderPath = projectItemTuple.Item2;
var folderPath = currentFolderPath + projectItem.Name + "\\";
folders.Add(folderPath);
projectItem.ProjectItems.OfType<ProjectItem>().Where(n => n.IsFolder()).Do(n => projectItemsStack.Push(Tuple.Create(n, folderPath)));
}
}
return folders;
}
public string GetDefaultNamespace(Microsoft.CodeAnalysis.Project project, Workspace workspace)
{
this.AssertIsForeground();
if (project.Language == LanguageNames.VisualBasic)
{
return "";
}
var folders = new List<string>();
var defaultNamespace = "";
if (workspace is VisualStudioWorkspaceImpl)
{
((VisualStudioWorkspaceImpl)workspace).GetProjectData(project.Id, out var ivisualStudioHostProject, out var hierarchy, out var envDTEProject);
try
{
defaultNamespace = (string)envDTEProject.ProjectItems.ContainingProject.Properties.Item("DefaultNamespace").Value; // Do not Localize
}
catch (ArgumentException)
{
// DefaultNamespace does not exist for this project.
}
}
return defaultNamespace;
}
public static async Task<string> GetFormattedDocument(Workspace workspace, OptionSet options, Document document)
{
var formattedDocument = await Formatter.FormatAsync(document, options);
var newText = (await formattedDocument.GetTextAsync()).ToString();
newText = EnsureProperNewLine(newText, options);
return newText;
}
private static Document GetCodeAnalysisDocumentFromDteDocument(EnvDTE.Document activeDocument, Workspace workspace)
{
var documentId = workspace.CurrentSolution.GetDocumentIdsWithFilePath(activeDocument.FullName).FirstOrDefault();
if (documentId == null) return null;
return workspace.CurrentSolution.GetDocument(documentId);
}
private void ConditionallyCollapseOutliningRegions(
IVsTextView textView,
IWpfTextView wpfTextView,
Microsoft.CodeAnalysis.Workspace workspace,
bool isOpenMetadataAsSource
)
{
var outliningManagerService =
this.Package.ComponentModel.GetService <IOutliningManagerService>();
var outliningManager = outliningManagerService.GetOutliningManager(wpfTextView);
if (outliningManager == null)
{
return;
}
if (
!workspace.Options.GetOption(FeatureOnOffOptions.Outlining, this.RoslynLanguageName)
)
{
outliningManager.Enabled = false;
}
else
{
if (textView is IVsTextViewEx viewEx)
{
if (isOpenMetadataAsSource)
{
// If this file is a metadata-from-source file, we want to force-collapse any implementations.
// First make sure we know what all the outlining spans are. Then ask the outlining mananger
// to collapse all the implementation spans.
EnsureOutliningTagsComputed(wpfTextView);
outliningManager.CollapseAll(
wpfTextView.TextBuffer.CurrentSnapshot.GetFullSpan(),
c => c.Tag.IsImplementation
);
}
else
{
// We also want to automatically collapse any region tags *on the first
// load of a file* if the file contains them. In order to not do expensive
// parsing, we only do this if the file contains #region in it.
if (ContainsRegionTag(wpfTextView.TextSnapshot))
{
// Make sure we at least know what the outlining spans are.
// Then when we call PersistOutliningState below the editor will
// get these outlining tags and automatically collapse any
// IsDefaultCollapsed spans the first time around.
//
// If it is not the first time opening a file, VS will simply use
// the data stored in the SUO file.
EnsureOutliningTagsComputed(wpfTextView);
}
viewEx.PersistOutliningState();
}
}
}
}
public APMRefactoring(Solution originalSolution, Workspace workspace)
{
_workspace = workspace;
if (originalSolution == null) throw new ArgumentNullException("originalSolution");
if (workspace == null) throw new ArgumentNullException("workspace");
OriginalSolution = originalSolution;
}
public WorkspaceManager(Microsoft.CodeAnalysis.Workspace workspace)
{
workspace.WorkspaceChanged += WorkspaceChanged;
if (workspace.CurrentSolution != null)
{
Task.Run(() => AddToCacheAsync(workspace.CurrentSolution.Projects));
}
}
public static async Task<long> GetSolutionSizeAsync (Workspace workspace, SolutionId id, CancellationToken cancellationToken)
{
long result = 0;
foreach (var project in workspace.CurrentSolution.Projects) {
result += await GetProjectSizeAsync (project, cancellationToken);
}
return result;
}
public RoslynSolutionWatcher(DTE dte, Workspace workspace, ICoverageStore coverageStore, IRewrittenDocumentsStorage rewrittenDocumentsStorage, ITaskCoverageManager taskCoverageManager)
{
_dte = dte;
_workspace = workspace;
_coverageStore = coverageStore;
_rewrittenDocumentsStorage = rewrittenDocumentsStorage;
_taskCoverageManager = taskCoverageManager;
}
private void SendErrorNotification(Workspace workspace, string message1, string message2)
{
var notificationService = workspace.Services.GetService <INotificationService>();
notificationService.SendNotification(
message1 + Environment.NewLine + Environment.NewLine + message2,
severity: NotificationSeverity.Error
);
}
public RemotableDataJsonRpc(Microsoft.CodeAnalysis.Workspace workspace, Stream stream)
: base(stream, callbackTarget: null, useThisAsCallback: true)
{
_remotableDataService = workspace.Services.GetService <IRemotableDataService>();
_shutdownCancellationSource = new CancellationTokenSource();
StartListening();
}
public TextAdornment1(Microsoft.VisualStudio.Text.Editor.IWpfTextView view)
{
var componentModel = (Microsoft.VisualStudio.ComponentModelHost.IComponentModel)Microsoft.VisualStudio.Shell.Package.GetGlobalService(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel));
Workspace = componentModel.GetService <Microsoft.VisualStudio.LanguageServices.VisualStudioWorkspace>();
View = view;
View.LayoutChanged += OnLayoutChanged;
}
private Workspace TryGetWorkspace()
{
if (_workspace == null)
{
var componentModel = (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel));
_workspace = componentModel.DefaultExportProvider.GetExportedValueOrDefault <VisualStudioWorkspace>();
}
return(_workspace);
}
public IIncrementalAnalyzer CreateIncrementalAnalyzer(Microsoft.CodeAnalysis.Workspace workspace)
{
var visualStudioWorkspace = workspace as VisualStudioWorkspaceImpl;
if (visualStudioWorkspace == null)
{
return(null);
}
return(new Analyzer(_notificationService, _listener, visualStudioWorkspace));
}
public MonoDevelopAnalyzer(FilePath fullPath, HostDiagnosticUpdateSource hostDiagnosticUpdateSource, ProjectId projectId, Microsoft.CodeAnalysis.Workspace workspace, IAnalyzerAssemblyLoader loader, string language)
{
FullPath = fullPath;
_hostDiagnosticUpdateSource = hostDiagnosticUpdateSource;
_projectId = projectId;
_workspace = workspace;
_loader = loader;
_language = language;
FileService.FileChanged += OnUpdatedOnDisk;
}
private void ApplyChanges(Microsoft.CodeAnalysis.Workspace workspace, Document document)
{
if (IsBatchOpen)
{
_batchDocument = document;
}
else
{
workspace.TryApplyChanges(document.Project.Solution);
}
}
public string GetProjectType(Microsoft.CodeAnalysis.Workspace workspace, ProjectId projectId)
{
if (workspace == null || projectId == null)
{
return(string.Empty);
}
var vsWorkspace = workspace as VisualStudioWorkspaceImpl;
var project = vsWorkspace?.GetHostProject(projectId) as AbstractLegacyProject;
return(project?.ProjectType ?? string.Empty);
}
public void AddWorkspace(Microsoft.CodeAnalysis.Workspace ws, CancellationToken token)
{
workspaces.Add(ws);
ws.WorkspaceChanged += Ws_WorkspaceChanged;
foreach (var p in ws.CurrentSolution.Projects)
{
if (p.FilePath.EndsWith("csproj", StringComparison.Ordinal))
{
SearchAsync(documentInfos, p, token);
}
}
}
private Workspace TryGetWorkspace()
{
if (_workspace == null)
{
var componentModel = (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel));
var provider = componentModel.DefaultExportProvider.GetExportedValueOrDefault <ISolutionExplorerWorkspaceProvider>();
if (provider != null)
{
_workspace = provider.GetWorkspace();
}
}
return(_workspace);
}
public static async Task <ServiceHubRemoteHostClient> CreateWorkerAsync(Workspace workspace, HubClient primary, TimeSpan timeout, CancellationToken cancellationToken)
{
ServiceHubRemoteHostClient client = null;
try
{
// let each client to have unique id so that we can distinguish different clients when service is restarted
var current = CreateClientId(Process.GetCurrentProcess().Id.ToString());
var hostGroup = new HostGroup(current);
// Create the RemotableDataJsonRpc before we create the remote host: this call implicitly sets up the remote IExperimentationService so that will be available for later calls
var remotableDataRpc = new RemotableDataJsonRpc(
workspace, primary.Logger,
await Connections.RequestServiceAsync(workspace, primary, WellKnownServiceHubServices.SnapshotService, hostGroup, timeout, cancellationToken).ConfigureAwait(false));
var remoteHostStream = await Connections.RequestServiceAsync(workspace, primary, WellKnownRemoteHostServices.RemoteHostService, hostGroup, timeout, cancellationToken).ConfigureAwait(false);
var enableConnectionPool = workspace.Options.GetOption(RemoteHostOptions.EnableConnectionPool);
var maxConnection = workspace.Options.GetOption(RemoteHostOptions.MaxPoolConnection);
var connectionManager = new ConnectionManager(primary, hostGroup, enableConnectionPool, maxConnection, timeout, new ReferenceCountedDisposable <RemotableDataJsonRpc>(remotableDataRpc));
client = new ServiceHubRemoteHostClient(workspace, primary.Logger, connectionManager, remoteHostStream);
var uiCultureLCID = CultureInfo.CurrentUICulture.LCID;
var cultureLCID = CultureInfo.CurrentCulture.LCID;
// make sure connection is done right
var host = await client._rpc.InvokeWithCancellationAsync <string>(
nameof(IRemoteHostService.Connect), new object[] { current, uiCultureLCID, cultureLCID, TelemetryService.DefaultSession.SerializeSettings() }, cancellationToken).ConfigureAwait(false);
return(client);
}
catch (ConnectionLostException ex)
{
RemoteHostCrashInfoBar.ShowInfoBar(workspace, ex);
Shutdown(client, ex, cancellationToken);
// dont crash VS because OOP is failed to start. we will show info bar telling users to restart
// but never physically crash VS.
throw new SoftCrashException("Connection Lost", ex, cancellationToken);
}
catch (Exception ex)
{
Shutdown(client, ex, cancellationToken);
throw;
}
public static async Task <RemoteHostClient?> CreateAsync(Workspace workspace, CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.ServiceHubRemoteHostClient_CreateAsync, cancellationToken))
{
var enableConnectionPool = workspace.Options.GetOption(RemoteHostOptions.EnableConnectionPool);
var maxConnection = workspace.Options.GetOption(RemoteHostOptions.MaxPoolConnection);
// let each client to have unique id so that we can distinguish different clients when service is restarted
var clientId = CreateClientId(Process.GetCurrentProcess().Id.ToString());
var hostGroup = new HostGroup(clientId);
var hubClient = new HubClient("ManagedLanguage.IDE.RemoteHostClient");
// use the hub client logger for unexpected exceptions from devenv as well, so we have complete information in the log:
WatsonReporter.InitializeLogger(hubClient.Logger);
var remoteHostStream = await RequestServiceAsync(workspace, hubClient, WellKnownRemoteHostServices.RemoteHostService, hostGroup, cancellationToken).ConfigureAwait(false);
var connectionManager = new ConnectionManager(workspace, hubClient, hostGroup, enableConnectionPool, maxConnection);
var client = new ServiceHubRemoteHostClient(workspace, hubClient.Logger, connectionManager, remoteHostStream);
var uiCultureLCID = CultureInfo.CurrentUICulture.LCID;
var cultureLCID = CultureInfo.CurrentCulture.LCID;
bool success = false;
try
{
// initialize the remote service
_ = await client._endPoint.InvokeAsync <string>(
nameof(IRemoteHostService.Connect),
new object[] { clientId, uiCultureLCID, cultureLCID, TelemetryService.DefaultSession.SerializeSettings() },
cancellationToken).ConfigureAwait(false);
success = true;
}
finally
{
if (!success)
{
client.Dispose();
}
}
client.Started();
return(client);
}
}
public static LinePosition GetAdjustedLineColumn(Microsoft.CodeAnalysis.Workspace workspace, DocumentId documentId, int originalLine, int originalColumn, int mappedLine, int mappedColumn)
{
var vsWorkspace = workspace as VisualStudioWorkspaceImpl;
if (vsWorkspace == null)
{
return(new LinePosition(mappedLine, mappedColumn));
}
if (TryAdjustSpanIfNeededForVenus(vsWorkspace, documentId, originalLine, originalColumn, out var span))
{
return(span.MappedLinePosition);
}
return(new LinePosition(mappedLine, mappedColumn));
}
private ServiceHubRemoteHostClient(
Workspace workspace,
TraceSource logger,
ConnectionManager connectionManager,
Stream stream)
: base(workspace)
{
_shutdownCancellationTokenSource = new CancellationTokenSource();
_connectionManager = connectionManager;
_endPoint = new RemoteEndPoint(stream, logger, incomingCallTarget: this);
_endPoint.Disconnected += OnDisconnected;
_endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown;
_endPoint.StartListening();
}
public static async Task <ServiceHubRemoteHostClient> CreateWorkerAsync(Workspace workspace, HubClient primary, TimeSpan timeout, CancellationToken cancellationToken)
{
ServiceHubRemoteHostClient client = null;
try
{
// let each client to have unique id so that we can distinguish different clients when service is restarted
var current = CreateClientId(Process.GetCurrentProcess().Id.ToString());
var hostGroup = new HostGroup(current);
// Create the RemotableDataJsonRpc before we create the remote host: this call implicitly sets up the remote IExperimentationService so that will be available for later calls
var remotableDataRpc = new RemotableDataJsonRpc(
workspace, primary.Logger,
await Connections.RequestServiceAsync(workspace, primary, WellKnownServiceHubServices.SnapshotService, hostGroup, timeout, cancellationToken).ConfigureAwait(false));
var remoteHostStream = await Connections.RequestServiceAsync(workspace, primary, WellKnownRemoteHostServices.RemoteHostService, hostGroup, timeout, cancellationToken).ConfigureAwait(false);
var enableConnectionPool = workspace.Options.GetOption(RemoteHostOptions.EnableConnectionPool);
var maxConnection = workspace.Options.GetOption(RemoteHostOptions.MaxPoolConnection);
var connectionManager = new ConnectionManager(primary, hostGroup, enableConnectionPool, maxConnection, timeout, new ReferenceCountedDisposable <RemotableDataJsonRpc>(remotableDataRpc));
client = new ServiceHubRemoteHostClient(workspace, primary.Logger, connectionManager, remoteHostStream);
var uiCultureLCID = CultureInfo.CurrentUICulture.LCID;
var cultureLCID = CultureInfo.CurrentCulture.LCID;
// make sure connection is done right
var host = await client._rpc.InvokeWithCancellationAsync <string>(
nameof(IRemoteHostService.Connect), new object[] { current, uiCultureLCID, cultureLCID, TelemetryService.DefaultSession.SerializeSettings() }, cancellationToken).ConfigureAwait(false);
return(client);
}
catch (Exception ex)
{
// make sure we shutdown client if initializing client has failed.
client?.Shutdown();
// translate to our own cancellation if it is raised.
cancellationToken.ThrowIfCancellationRequested();
// otherwise, report watson and throw original exception
ex.ReportServiceHubNFW("ServiceHub creation failed");
throw;
}
}
private ServiceHubRemoteHostClient(
Workspace workspace,
ConnectionManager connectionManager,
Stream stream)
: base(workspace)
{
_shutdownCancellationTokenSource = new CancellationTokenSource();
_connectionManager = connectionManager;
_rpc = new JsonRpc(new JsonRpcMessageHandler(stream, stream), target: this);
_rpc.JsonSerializer.Converters.Add(AggregateJsonConverter.Instance);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
private ServiceHubRemoteHostClient(
Workspace workspace,
TraceSource logger,
ConnectionManager connectionManager,
Stream stream)
: base(workspace)
{
_shutdownCancellationTokenSource = new CancellationTokenSource();
_connectionManager = connectionManager;
_rpc = stream.CreateStreamJsonRpc(target: this, logger);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
public WorkspaceManager(Microsoft.CodeAnalysis.Workspace workspace)
{
watcher = new FileSystemWatcher
{
NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
IncludeSubdirectories = true,
Filter = "*.csproj"
};
watcher.Changed += (s, e) => UpdateProjectDescription(e.FullPath);
watcher.Renamed += (s, e) => UpdateProjectDescription(e.FullPath);
workspace.WorkspaceChanged += WorkspaceChanged;
if (workspace.CurrentSolution != null)
{
#pragma warning disable VSTHRD110 // Observe result of async calls
Task.Run(() => AddToCache(workspace.CurrentSolution));
#pragma warning restore VSTHRD110 // Observe result of async calls
}
}
public static DocumentId GetDocumentId(Microsoft.CodeAnalysis.Workspace workspace, MonoDevelop.Projects.Project project, string fileName)
{
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (fileName == null)
{
throw new ArgumentNullException(nameof(fileName));
}
fileName = FileService.GetFullPath(fileName);
var projectId = ((MonoDevelopWorkspace)workspace).GetProjectId(project);
if (projectId != null)
{
return(((MonoDevelopWorkspace)workspace).GetDocumentId(projectId, fileName));
}
else
{
LoggingService.LogWarning("Warning can't find " + fileName + " in project " + project.Name + "(" + projectId + ")");
}
return(null);
}
private ServiceHubRemoteHostClient(
Workspace workspace,
HubClient hubClient,
HostGroup hostGroup,
Stream stream)
: base(workspace)
{
if (workspace.Options.GetOption(RemoteHostOptions.EnableConnectionPool))
{
int maxPoolConnection = workspace.Options.GetOption(RemoteHostOptions.MaxPoolConnection);
_connectionPool = new ConnectionPool(
connectionFactory: (serviceName, cancellationToken) => CreateConnectionAsync(serviceName, callbackTarget: null, cancellationToken),
maxPoolConnection);
}
_hubClient = hubClient;
_hostGroup = hostGroup;
_endPoint = new RemoteEndPoint(stream, hubClient.Logger, incomingCallTarget: this);
_endPoint.Disconnected += OnDisconnected;
_endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown;
_endPoint.StartListening();
}
static void UpdateWorkspaceOptions(Microsoft.CodeAnalysis.Workspace ws)
{
// Roslyn uses | as separator.
ws.Options = ws.Options.WithChangedOption(TodoCommentOptions.TokenList, CommentTag.ToString(CommentTag.SpecialCommentTags, "|"));
}