public async Task TestSessionClosed()
{
// enable local remote host service
var service = CreateRemoteHostClientService();
service.Enable();
var client = (InProcRemoteHostClient)(await service.TryGetRemoteHostClientAsync(CancellationToken.None));
// register local service
TestService testService = null;
client.RegisterService("Test", (s, p) =>
{
testService = new TestService(s, p);
return(testService);
});
// create session that stay alive until client alive (ex, SymbolSearchUpdateEngine)
var session = await client.TryCreateKeepAliveSessionAsync("Test", CancellationToken.None);
// mimic unfortunate call that happens to be in the middle of communication.
var task = session.TryInvokeAsync("TestMethodAsync", SpecializedCollections.EmptyReadOnlyList <object>(), CancellationToken.None);
// make client to go away
service.Disable();
// let the service to return
testService.Event.Set();
// make sure task finished gracefully
await task;
}
private SimpleDiagnostic(
DiagnosticDescriptor descriptor,
DiagnosticSeverity severity,
int warningLevel,
Location location,
IEnumerable <Location> additionalLocations,
object[] messageArgs,
ImmutableDictionary <string, string> properties)
{
if ((warningLevel == 0 && severity != DiagnosticSeverity.Error) ||
(warningLevel != 0 && severity == DiagnosticSeverity.Error))
{
throw new ArgumentException(nameof(warningLevel));
}
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
_descriptor = descriptor;
_severity = severity;
_warningLevel = warningLevel;
_location = location ?? Location.None;
_additionalLocations = additionalLocations?.ToImmutableArray() ?? SpecializedCollections.EmptyReadOnlyList <Location>();
_messageArgs = messageArgs ?? SpecializedCollections.EmptyArray <object>();
_properties = properties ?? ImmutableDictionary <string, string> .Empty;
}
private void AttachToDocument(uint docCookie, string moniker)
{
_foregroundThreadAffinitization.AssertIsForeground();
var vsTextBuffer = (IVsTextBuffer)_runningDocumentTable.GetDocumentData(docCookie);
var textBuffer = _editorAdaptersFactoryService.GetDocumentBuffer(vsTextBuffer);
if (_fileTrackingMetadataAsSourceService.TryAddDocumentToWorkspace(moniker, textBuffer))
{
// We already added it, so we will keep it excluded from the misc files workspace
return;
}
// This should always succeed since we only got here if we already confirmed the moniker is acceptable
var languageInformation = TryGetLanguageInformation(moniker);
Contract.ThrowIfNull(languageInformation);
var parseOptions = languageInformation.ParseOptions;
if (Path.GetExtension(moniker) == languageInformation.ScriptExtension)
{
parseOptions = parseOptions.WithKind(SourceCodeKind.Script);
}
// First, create the project
var hostProject = new HostProject(this, CurrentSolution.Id, languageInformation.LanguageName, parseOptions, _metadataReferences);
// Now try to find the document. We accept any text buffer, since we've already verified it's an appropriate file in ShouldIncludeFile.
var document = _documentProvider.TryGetDocumentForFile(
hostProject,
moniker,
parseOptions.Kind,
getFolderNames: _ => SpecializedCollections.EmptyReadOnlyList <string>(),
canUseTextBuffer: _ => true);
// If the buffer has not yet been initialized, we won't get a document.
if (document == null)
{
return;
}
// Since we have a document, we can do the rest of the project setup.
_hostProjects.Add(hostProject.Id, hostProject);
OnProjectAdded(hostProject.CreateProjectInfoForCurrentState());
OnDocumentAdded(document.GetInitialState());
hostProject.Document = document;
// Notify the document provider, so it knows the document is now open and a part of
// the project
_documentProvider.NotifyDocumentRegisteredToProjectAndStartToRaiseEvents(document);
Contract.ThrowIfFalse(document.IsOpen);
var buffer = document.GetOpenTextBuffer();
OnDocumentOpened(document.Id, document.GetOpenTextContainer());
_docCookiesToHostProject.Add(docCookie, hostProject);
}
internal CSDiagnosticInfo(ErrorCode code, object[] args, ImmutableArray <Symbol> symbols, ImmutableArray <Location> additionalLocations)
: base(code, args, symbols)
{
// Internal errors are abnormal and should not occur except where there are bugs in the compiler.
Debug.Assert(code != ErrorCode.ERR_InternalError);
_additionalLocations = additionalLocations.IsDefaultOrEmpty ? SpecializedCollections.EmptyReadOnlyList <Location>() : additionalLocations;
}
public static SourceGeneratedDocumentState Create(
SourceGeneratedDocumentIdentity documentIdentity,
SourceText generatedSourceText,
ParseOptions parseOptions,
HostLanguageServices languageServices,
SolutionServices solutionServices)
{
var textAndVersion = TextAndVersion.Create(generatedSourceText, VersionStamp.Create());
var textSource = new ConstantValueSource <TextAndVersion>(textAndVersion);
var treeSource = CreateLazyFullyParsedTree(
textSource,
documentIdentity.DocumentId.ProjectId,
documentIdentity.FilePath,
parseOptions,
languageServices);
return(new SourceGeneratedDocumentState(
documentIdentity,
languageServices,
solutionServices,
documentServiceProvider: null,
new DocumentInfo.DocumentAttributes(
documentIdentity.DocumentId,
name: documentIdentity.HintName,
folders: SpecializedCollections.EmptyReadOnlyList <string>(),
parseOptions.Kind,
filePath: documentIdentity.FilePath,
isGenerated: true,
designTimeOnly: false),
parseOptions,
textSource,
treeSource));
}
protected static void AddMappedDocument(Workspace workspace, string markup)
{
var generatedDocumentId = DocumentId.CreateNewId(
workspace.CurrentSolution.ProjectIds.First()
);
var version = VersionStamp.Create();
var loader = TextLoader.From(
TextAndVersion.Create(
SourceText.From(markup),
version,
TestSpanMapper.GeneratedFileName
)
);
var generatedDocumentInfo = DocumentInfo.Create(
generatedDocumentId,
TestSpanMapper.GeneratedFileName,
SpecializedCollections.EmptyReadOnlyList <string>(),
SourceCodeKind.Regular,
loader,
$"C:\\{TestSpanMapper.GeneratedFileName}",
isGenerated: true,
designTimeOnly: false,
new TestSpanMapperProvider()
);
var newSolution = workspace.CurrentSolution.AddDocument(generatedDocumentInfo);
workspace.TryApplyChanges(newSolution);
}
internal SimpleDiagnostic(string id, string category, string message, DiagnosticSeverity severity, bool isEnabledByDefault,
int warningLevel, bool isWarningAsError, Location location,
IEnumerable <Location> additionalLocations, IEnumerable <string> customTags)
{
if (isWarningAsError && severity != DiagnosticSeverity.Warning)
{
throw new ArgumentException("isWarningAsError");
}
if ((warningLevel == 0 && severity == DiagnosticSeverity.Warning) ||
(warningLevel != 0 && severity != DiagnosticSeverity.Warning))
{
throw new ArgumentException("warningLevel");
}
this.id = id;
this.category = category;
this.message = message;
this.severity = severity;
this.isEnabledByDefault = isEnabledByDefault;
this.warningLevel = warningLevel;
this.isWarningAsError = isWarningAsError;
this.location = location;
this.additionalLocations = additionalLocations == null?SpecializedCollections.EmptyReadOnlyList <Location>() : additionalLocations.ToImmutableArray();
this.customTags = customTags == null?SpecializedCollections.EmptyReadOnlyList <string>() : customTags.ToImmutableArray();
}
private SimpleDiagnostic(
DiagnosticDescriptor descriptor,
DiagnosticSeverity severity,
int warningLevel,
Location location,
IEnumerable <Location> additionalLocations,
object[] messageArgs,
ImmutableDictionary <string, string> properties,
bool isSuppressed)
{
if ((warningLevel == 0 && severity != DiagnosticSeverity.Error) ||
(warningLevel != 0 && severity == DiagnosticSeverity.Error))
{
throw new ArgumentException($"{nameof(warningLevel)} ({warningLevel}) and {nameof(severity)} ({severity}) are not compatible.", nameof(warningLevel));
}
_descriptor = descriptor ?? throw new ArgumentNullException(nameof(descriptor));
_severity = severity;
_warningLevel = warningLevel;
_location = location ?? Location.None;
_additionalLocations = additionalLocations?.ToImmutableArray() ?? SpecializedCollections.EmptyReadOnlyList <Location>();
_messageArgs = messageArgs ?? Array.Empty <object>();
_properties = properties ?? ImmutableDictionary <string, string> .Empty;
_isSuppressed = isSuppressed;
}
/// <summary>
/// Creates a <see cref="StandardTextDocument"/>.
/// <para>Note: getFolderNames maps from a VSITEMID to the folders this document should be contained in.</para>
/// </summary>
public StandardTextDocument(
DocumentProvider documentProvider,
AbstractProject project,
DocumentKey documentKey,
Func <uint, IReadOnlyList <string> > getFolderNames,
SourceCodeKind sourceCodeKind,
IVsFileChangeEx fileChangeService,
ITextBuffer openTextBuffer,
DocumentId id,
EventHandler updatedOnDiskHandler,
EventHandler <bool> openedHandler,
EventHandler <bool> closingHandler)
{
Contract.ThrowIfNull(documentProvider);
this.Project = project;
this.Id = id ?? DocumentId.CreateNewId(project.Id, documentKey.Moniker);
_itemMoniker = documentKey.Moniker;
var itemid = this.GetItemId();
this.Folders = itemid == (uint)VSConstants.VSITEMID.Nil
? SpecializedCollections.EmptyReadOnlyList <string>()
: getFolderNames(itemid);
_documentProvider = documentProvider;
this.Key = documentKey;
this.SourceCodeKind = sourceCodeKind;
_fileChangeTracker = new FileChangeTracker(fileChangeService, this.FilePath);
_fileChangeTracker.UpdatedOnDisk += OnUpdatedOnDisk;
_openTextBuffer = openTextBuffer;
_snapshotTracker = new ReiteratedVersionSnapshotTracker(openTextBuffer);
// The project system does not tell us the CodePage specified in the proj file, so
// we use null to auto-detect.
_doNotAccessDirectlyLoader = new FileTextLoader(documentKey.Moniker, defaultEncoding: null);
// If we aren't already open in the editor, then we should create a file change notification
if (openTextBuffer == null)
{
_fileChangeTracker.StartFileChangeListeningAsync();
}
if (updatedOnDiskHandler != null)
{
UpdatedOnDisk += updatedOnDiskHandler;
}
if (openedHandler != null)
{
Opened += openedHandler;
}
if (closingHandler != null)
{
Closing += closingHandler;
}
}
public static SourceGeneratedDocumentState Create(
string hintName,
SourceText generatedSourceText,
SyntaxTree generatedSyntaxTree,
DocumentId documentId,
ISourceGenerator sourceGenerator,
HostLanguageServices languageServices,
SolutionServices solutionServices,
CancellationToken cancellationToken)
{
var options = generatedSyntaxTree.Options;
var filePath = generatedSyntaxTree.FilePath;
var textAndVersion = TextAndVersion.Create(generatedSourceText, VersionStamp.Create());
ValueSource <TextAndVersion> textSource = new ConstantValueSource <TextAndVersion>(textAndVersion);
var root = generatedSyntaxTree.GetRoot(cancellationToken);
Contract.ThrowIfNull(languageServices.SyntaxTreeFactory, "We should not have a generated syntax tree for a language that doesn't support trees.");
if (languageServices.SyntaxTreeFactory.CanCreateRecoverableTree(root))
{
// We will only create recoverable text if we can create a recoverable tree; if we created a
// recoverable text but not a new tree, it would mean tree.GetText() could still potentially return
// the non-recoverable text, but asking the document directly for it's text would give a recoverable
// text with a different object identity.
textSource = CreateRecoverableText(textAndVersion, solutionServices);
generatedSyntaxTree = languageServices.SyntaxTreeFactory.CreateRecoverableTree(
documentId.ProjectId,
filePath: generatedSyntaxTree.FilePath,
options,
textSource,
generatedSourceText.Encoding,
root);
}
var treeAndVersion = TreeAndVersion.Create(generatedSyntaxTree, textAndVersion.Version);
return(new SourceGeneratedDocumentState(
languageServices,
solutionServices,
documentServiceProvider: null,
new DocumentInfo.DocumentAttributes(
documentId,
name: hintName,
folders: SpecializedCollections.EmptyReadOnlyList <string>(),
options.Kind,
filePath: filePath,
isGenerated: true,
designTimeOnly: false),
options,
sourceText: null, // don't strongly hold the text
textSource,
treeAndVersion,
sourceGenerator,
hintName));
}
private bool TryCreateXamlDocument(AbstractProject project, string filePath, out IVisualStudioHostDocument vsDocument)
{
vsDocument = _vsWorkspace.ProjectTracker.DocumentProvider.TryGetDocumentForFile(
project, filePath, SourceCodeKind.Regular,
tb => tb.ContentType.IsOfType(ContentTypeNames.XamlContentType),
_ => SpecializedCollections.EmptyReadOnlyList <string>());
return(vsDocument != null);
}
public IReadOnlyList <SyntaxNode> GetNodes(SyntaxAnnotation id)
{
if (_idToNodeMap.TryGetValue(id, out var nodes))
{
return(nodes);
}
else
{
return(SpecializedCollections.EmptyReadOnlyList <SyntaxNode>());
}
}
internal CSharpCompilerInputs(CSharpProjectFile projectFile)
{
_projectFile = projectFile;
this.Options = new HostBuildOptions();
this.Sources = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.References = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.AnalyzerReferences = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.AdditionalFiles = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.LibPaths = SpecializedCollections.EmptyReadOnlyList <string>();
this.Options.ProjectDirectory = Path.GetDirectoryName(projectFile.FilePath);
this.Options.OutputDirectory = projectFile.GetOutputDirectory();
}
private static IReadOnlyList <SyntaxNode> GetCurrentNodeFromTrueRoots(SyntaxNode trueRoot, SyntaxNode node)
{
var id = GetId(node);
if (id != null)
{
CurrentNodes tracked = s_rootToCurrentNodesMap.GetValue(trueRoot, r => new CurrentNodes(r));
return(tracked.GetNodes(id));
}
else
{
return(SpecializedCollections.EmptyReadOnlyList <SyntaxNode>());
}
}
public IFormattingResult GetFormattingResult(SyntaxNode node, IEnumerable <TextSpan>?spans, SyntaxFormattingOptions options, IEnumerable <AbstractFormattingRule>?rules, CancellationToken cancellationToken)
{
IReadOnlyList <TextSpan> spansToFormat;
if (spans == null)
{
spansToFormat = node.FullSpan.IsEmpty ?
SpecializedCollections.EmptyReadOnlyList <TextSpan>() :
SpecializedCollections.SingletonReadOnlyList(node.FullSpan);
}
else
{
spansToFormat = new NormalizedTextSpanCollection(spans.Where(s_notEmpty));
}
if (spansToFormat.Count == 0)
{
return(CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList <AbstractFormattingResult>()));
}
rules ??= GetDefaultFormattingRules();
List <AbstractFormattingResult>?results = null;
foreach (var(startToken, endToken) in node.ConvertToTokenPairs(spansToFormat))
{
if (node.IsInvalidTokenRange(startToken, endToken))
{
continue;
}
results ??= new List <AbstractFormattingResult>();
results.Add(Format(node, options, rules, startToken, endToken, cancellationToken));
}
// quick simple case check
if (results == null)
{
return(CreateAggregatedFormattingResult(node, SpecializedCollections.EmptyList <AbstractFormattingResult>()));
}
if (results.Count == 1)
{
return(results[0]);
}
// more expensive case
return(CreateAggregatedFormattingResult(node, results));
}
private static IReadOnlyList <string> GetCustomTags(ObjectReader reader, int count)
{
if (count > 0)
{
var tags = new List <string>(count);
for (var i = 0; i < count; i++)
{
tags.Add(reader.ReadString());
}
return(new ReadOnlyCollection <string>(tags));
}
return(SpecializedCollections.EmptyReadOnlyList <string>());
}
public IReadOnlyList <string> GetFolderNames(uint documentItemID)
{
object parentObj;
if (documentItemID != (uint)VSConstants.VSITEMID.Nil && Hierarchy.GetProperty(documentItemID, (int)VsHierarchyPropID.Parent, out parentObj) == VSConstants.S_OK)
{
var parentID = UnboxVSItemId(parentObj);
if (parentID != (uint)VSConstants.VSITEMID.Nil && parentID != (uint)VSConstants.VSITEMID.Root)
{
return(GetFolderNamesForFolder(parentID));
}
}
return(SpecializedCollections.EmptyReadOnlyList <string>());
}
public void AddAdditionalFile(string additionalFilePath, Func <IVisualStudioHostDocument, bool> getIsInCurrentContext)
{
var document = this.DocumentProvider.TryGetDocumentForFile(
this,
filePath: additionalFilePath,
sourceCodeKind: SourceCodeKind.Regular,
getFolderNames: _ => SpecializedCollections.EmptyReadOnlyList <string>(),
canUseTextBuffer: _ => true,
updatedOnDiskHandler: s_additionalDocumentUpdatedOnDiskEventHandler,
openedHandler: s_additionalDocumentOpenedEventHandler,
closingHandler: s_additionalDocumentClosingEventHandler);
if (document == null)
{
return;
}
AddAdditionalDocument(document, isCurrentContext: getIsInCurrentContext(document));
}
internal CSharpCompilerInputs(CSharpProjectFile projectFile)
{
this.projectFile = projectFile;
var projectDirectory = Path.GetDirectoryName(projectFile.FilePath);
var outputDirectory = projectFile.GetOutputDirectory();
this.ParseOptions = defaultParseOptions;
this.CompilationOptions = new CSharpCompilationOptions(
OutputKind.ConsoleApplication,
xmlReferenceResolver: new XmlFileResolver(projectDirectory),
sourceReferenceResolver: new SourceFileResolver(ImmutableArray <string> .Empty, projectDirectory),
metadataReferenceResolver: new MetadataFileReferenceResolver(ImmutableArray <string> .Empty, projectDirectory),
metadataReferenceProvider: MetadataFileReferenceProvider.Default,
strongNameProvider: new DesktopStrongNameProvider(ImmutableArray.Create(projectDirectory, outputDirectory)),
assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default);
this.Warnings = new Dictionary <string, ReportDiagnostic>();
this.Sources = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.References = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.AnalyzerReferences = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.AdditionalFiles = SpecializedCollections.EmptyEnumerable <MSB.Framework.ITaskItem>();
this.LibPaths = SpecializedCollections.EmptyReadOnlyList <string>();
}
private SimpleDiagnostic(
DiagnosticDescriptor descriptor,
DiagnosticSeverity severity,
int warningLevel,
Location location,
IEnumerable <Location> additionalLocations,
object[] messageArgs)
{
if ((warningLevel == 0 && severity != DiagnosticSeverity.Error) ||
(warningLevel != 0 && severity == DiagnosticSeverity.Error))
{
throw new ArgumentException("warningLevel");
}
_descriptor = descriptor;
_severity = severity;
_warningLevel = warningLevel;
_location = location;
_additionalLocations = additionalLocations == null?SpecializedCollections.EmptyReadOnlyList <Location>() : additionalLocations.ToImmutableArray();
_messageArgs = messageArgs ?? SpecializedCollections.EmptyArray <object>();
}
private async Task <IReadOnlyList <Reference> > FindResultsAsync(
Document document, SemanticModel semanticModel, Diagnostic diagnostic, SyntaxNode node, CancellationToken cancellationToken)
{
// Caches so we don't produce the same data multiple times while searching
// all over the solution.
var project = document.Project;
var projectToAssembly = new ConcurrentDictionary <Project, AsyncLazy <IAssemblySymbol> >(concurrencyLevel: 2, capacity: project.Solution.ProjectIds.Count);
var referenceToCompilation = new ConcurrentDictionary <PortableExecutableReference, Compilation>(concurrencyLevel: 2, capacity: project.Solution.Projects.Sum(p => p.MetadataReferences.Count));
var finder = new SymbolReferenceFinder(this, document, semanticModel, diagnostic, node, cancellationToken);
// Look for exact matches first:
var exactReferences = await FindResultsAsync(projectToAssembly, referenceToCompilation, project, finder, exact : true, cancellationToken : cancellationToken).ConfigureAwait(false);
if (exactReferences?.Count > 0)
{
return(exactReferences);
}
// No exact matches found. Fall back to fuzzy searching.
// Only bother doing this for host workspaces. We don't want this for
// things like the Interactive workspace as this will cause us to
// create expensive bktrees which we won't even be able to save for
// future use.
if (!IsHostOrTestWorkspace(project))
{
return(SpecializedCollections.EmptyReadOnlyList <Reference>());
}
var fuzzyReferences = await FindResultsAsync(projectToAssembly, referenceToCompilation, project, finder, exact : false, cancellationToken : cancellationToken).ConfigureAwait(false);
if (fuzzyReferences?.Count > 0)
{
return(fuzzyReferences);
}
return(null);
}
public IEnumerable <IMethodDefinition> GetMethods(EmitContext context)
{
return(_methods ??= SpecializedCollections.EmptyReadOnlyList <IMethodDefinition>());
}
private void AttachToDocument(uint docCookie, string moniker)
{
_foregroundThreadAffinitization.AssertIsForeground();
var vsTextBuffer = (IVsTextBuffer)_runningDocumentTable.GetDocumentData(docCookie);
var textBuffer = _editorAdaptersFactoryService.GetDocumentBuffer(vsTextBuffer);
if (_fileTrackingMetadataAsSourceService.TryAddDocumentToWorkspace(moniker, textBuffer))
{
// We already added it, so we will keep it excluded from the misc files workspace
return;
}
// This should always succeed since we only got here if we already confirmed the moniker is acceptable
var languageInformation = TryGetLanguageInformation(moniker);
Contract.ThrowIfNull(languageInformation);
var languageServices = Services.GetLanguageServices(languageInformation.LanguageName);
var compilationOptionsOpt = languageServices.GetService <ICompilationFactoryService>()?.GetDefaultCompilationOptions();
var parseOptionsOpt = languageServices.GetService <ISyntaxTreeFactoryService>()?.GetDefaultParseOptions();
if (parseOptionsOpt != null &&
compilationOptionsOpt != null &&
PathUtilities.GetExtension(moniker) == languageInformation.ScriptExtension)
{
parseOptionsOpt = parseOptionsOpt.WithKind(SourceCodeKind.Script);
var metadataService = Services.GetService <IMetadataService>();
var directory = PathUtilities.GetDirectoryName(moniker);
// TODO (https://github.com/dotnet/roslyn/issues/5325, https://github.com/dotnet/roslyn/issues/13886):
// - Need to have a way to specify these somewhere in VS options.
// - Use RuntimeMetadataReferenceResolver like in InteractiveEvaluator.CreateMetadataReferenceResolver
// - Add default namespace imports
// - Add default script globals available in 'csi goo.csx' environment: CommandLineScriptGlobals
var referenceSearchPaths = ImmutableArray <string> .Empty;
var sourceSearchPaths = ImmutableArray <string> .Empty;
var referenceResolver = new WorkspaceMetadataFileReferenceResolver(
metadataService,
new RelativePathResolver(referenceSearchPaths, directory));
compilationOptionsOpt = compilationOptionsOpt.
WithMetadataReferenceResolver(referenceResolver).
WithSourceReferenceResolver(new SourceFileResolver(sourceSearchPaths, directory));
}
// First, create the project
var hostProject = new HostProject(this, CurrentSolution.Id, languageInformation.LanguageName, parseOptionsOpt, compilationOptionsOpt, _metadataReferences);
// Now try to find the document. We accept any text buffer, since we've already verified it's an appropriate file in ShouldIncludeFile.
var document = _documentProvider.TryGetDocumentForFile(
hostProject,
moniker,
parseOptionsOpt?.Kind ?? SourceCodeKind.Regular,
getFolderNames: _ => SpecializedCollections.EmptyReadOnlyList <string>(),
canUseTextBuffer: _ => true);
// If the buffer has not yet been initialized, we won't get a document.
if (document == null)
{
return;
}
// Since we have a document, we can do the rest of the project setup.
_hostProjects.Add(hostProject.Id, hostProject);
OnProjectAdded(hostProject.CreateProjectInfoForCurrentState());
OnDocumentAdded(document.GetInitialState());
hostProject.Document = document;
// Notify the document provider, so it knows the document is now open and a part of
// the project
_documentProvider.NotifyDocumentRegisteredToProjectAndStartToRaiseEvents(document);
Contract.ThrowIfFalse(document.IsOpen);
var buffer = document.GetOpenTextBuffer();
OnDocumentOpened(document.Id, document.GetOpenTextContainer());
_docCookiesToHostProject.Add(docCookie, hostProject);
}
protected Task <TResult> InvokeAsync <TResult>(string targetName, CancellationToken cancellationToken)
{
return(InvokeAsync <TResult>(targetName, SpecializedCollections.EmptyReadOnlyList <object>(), cancellationToken));
}
public IReadOnlyList <string> GetFolderNames(uint documentItemID)
{
return(SpecializedCollections.EmptyReadOnlyList <string>());
}
public IReadOnlyList <Span> GetAdditionalInformationMatchRuns(string searchValue) => SpecializedCollections.EmptyReadOnlyList <Span>();