public bool TryGetSerializationPrefixAndVersion(Solution solution, string assemblyFilePath, out string prefix, out VersionStamp version)
{
prefix = string.Empty;
version = VersionStamp.Default;
return false;
}
public static bool CanReusePersistedTextVersion(this Document document, VersionStamp textVersion, VersionStamp persistedVersion)
{
var canReuse = VersionStamp.CanReusePersistedVersion(textVersion, persistedVersion);
PersistedVersionStampLogger.LogPersistedTextVersionUsage(canReuse);
return canReuse;
}
private Solution(
BranchId branchId,
int workspaceVersion,
SolutionServices solutionServices,
SolutionId id,
string filePath,
ImmutableList<ProjectId> projectIds,
ImmutableDictionary<ProjectId, ProjectState> idToProjectStateMap,
ImmutableDictionary<ProjectId, CompilationTracker> projectIdToTrackerMap,
ProjectDependencyGraph dependencyGraph,
VersionStamp version,
Lazy<VersionStamp> lazyLatestProjectVersion)
{
this.branchId = branchId;
this.workspaceVersion = workspaceVersion;
this.id = id;
this.filePath = filePath;
this.solutionServices = solutionServices;
this.projectIds = projectIds;
this.projectIdToProjectStateMap = idToProjectStateMap;
this.projectIdToTrackerMap = projectIdToTrackerMap;
this.dependencyGraph = dependencyGraph;
this.projectIdToProjectMap = ImmutableHashMap<ProjectId, Project>.Empty;
this.version = version;
this.lazyLatestProjectVersion = lazyLatestProjectVersion;
CheckInvariants();
}
public bool TryGetSerializationPrefixAndVersion(Solution solution, string assemblyFilePath, out string prefix, out VersionStamp version)
{
prefix = FilePathUtilities.GetRelativePath(solution.FilePath, assemblyFilePath);
version = VersionStamp.Create(File.GetLastWriteTimeUtc(assemblyFilePath));
return true;
}
public static bool CanReusePersistedDependentProjectVersion(this Project project, VersionStamp dependentProjectVersion, VersionStamp persistedVersion)
{
var canReuse = VersionStamp.CanReusePersistedVersion(dependentProjectVersion, persistedVersion);
PersistedVersionStampLogger.LogPersistedDependentProjectVersionUsage(canReuse);
return canReuse;
}
private SyntaxTreeContextInfo(VersionStamp version, int predefinedTypes, int predefinedOperators, ContainingNodes containingNodes) :
base(version)
{
_predefinedTypes = predefinedTypes;
_predefinedOperators = predefinedOperators;
_containingNodes = containingNodes;
}
internal static bool TryGetReference(
Solution solution, ProjectReference projectReference, Compilation finalOrDeclarationCompilation, VersionStamp version, out MetadataReference reference)
{
// if we have one from snapshot cache, use it. it will make sure same compilation will get same metadata reference always.
MetadataOnlyReferenceSet referenceSet;
if (s_snapshotCache.TryGetValue(finalOrDeclarationCompilation, out referenceSet))
{
reference = referenceSet.GetMetadataReference(finalOrDeclarationCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes);
return true;
}
// okay, now use version based cache that can live multiple compilation as long as there is no semantic changes.
// get one for the branch
if (TryGetReferenceFromBranch(solution.BranchId, projectReference, finalOrDeclarationCompilation, version, out reference))
{
return true;
}
// see whether we can use primary branch one
var primaryBranchId = solution.Workspace.PrimaryBranchId;
if (solution.BranchId != primaryBranchId &&
TryGetReferenceFromBranch(primaryBranchId, projectReference, finalOrDeclarationCompilation, version, out reference))
{
return true;
}
// noop, we don't have any
reference = null;
return false;
}
private SolutionState(
BranchId branchId,
int workspaceVersion,
SolutionServices solutionServices,
SolutionId id,
string filePath,
IEnumerable<ProjectId> projectIds,
ImmutableDictionary<ProjectId, ProjectState> idToProjectStateMap,
ImmutableDictionary<ProjectId, CompilationTracker> projectIdToTrackerMap,
ImmutableDictionary<string, ImmutableArray<DocumentId>> linkedFilesMap,
ProjectDependencyGraph dependencyGraph,
VersionStamp version,
Lazy<VersionStamp> lazyLatestProjectVersion)
{
_branchId = branchId;
_workspaceVersion = workspaceVersion;
_id = id;
_filePath = filePath;
_solutionServices = solutionServices;
_projectIds = projectIds.ToImmutableReadOnlyListOrEmpty();
_projectIdToProjectStateMap = idToProjectStateMap;
_projectIdToTrackerMap = projectIdToTrackerMap;
_linkedFilesMap = linkedFilesMap;
_dependencyGraph = dependencyGraph;
_version = version;
_lazyLatestProjectVersion = lazyLatestProjectVersion;
CheckInvariants();
}
public static bool CanReusePersistedSyntaxTreeVersion(this Document document, VersionStamp syntaxVersion, VersionStamp persistedVersion)
{
var canReuse = VersionStamp.CanReusePersistedVersion(syntaxVersion, persistedVersion);
PersistedVersionStampLogger.LogPersistedSyntaxTreeVersionUsage(canReuse);
return canReuse;
}
private static bool ShouldCreateFromScratch(
Solution solution,
IAssemblySymbol assembly,
string filePath,
out string prefix,
out VersionStamp version,
CancellationToken cancellationToken)
{
prefix = null;
version = default(VersionStamp);
var service = solution.Workspace.Services.GetService<IAssemblySerializationInfoService>();
if (service == null)
{
return true;
}
// check whether the assembly that belong to a solution is something we can serialize
if (!service.Serializable(solution, filePath))
{
return true;
}
if (!service.TryGetSerializationPrefixAndVersion(solution, filePath, out prefix, out version))
{
return true;
}
return false;
}
public NavigationBarModel(IList<NavigationBarItem> types, VersionStamp semanticVersionStamp, INavigationBarItemService itemService)
{
Contract.ThrowIfNull(types);
this.Types = types;
this.SemanticVersionStamp = semanticVersionStamp;
this.ItemService = itemService;
}
private SymbolTreeInfo(VersionStamp version, IReadOnlyList<Node> orderedNodes, SpellChecker spellChecker)
: this(version, orderedNodes, new Lazy<SpellChecker>(() => spellChecker))
{
// Make the lazy 'Created'. This is a no-op since we already have the underlying spell
// checker. This way if we end up wanting to serialize this tree info, we'll also
// serialize the spell checker.
var unused = _lazySpellChecker.Value;
}
/// <summary>
/// Create a new instance of a SolutionInfo.
/// </summary>
public static SolutionInfo Create(
SolutionId id,
VersionStamp version,
string filePath = null,
IEnumerable<ProjectInfo> projects = null)
{
return new SolutionInfo(new SolutionAttributes(id, version, filePath), projects);
}
public ProjectAnalysisData(ProjectId projectId, VersionStamp version, ImmutableDictionary<DiagnosticAnalyzer, AnalysisResult> result)
{
ProjectId = projectId;
Version = version;
Result = result;
OldResult = null;
}
/// <summary>
/// Create a new TextAndVersion instance.
/// </summary>
/// <param name="text">The text</param>
/// <param name="version">The version</param>
/// <param name="filePath">An optional file path that identifies the original of the source text.</param>
/// <returns></returns>
public static TextAndVersion Create(SourceText text, VersionStamp version, string filePath = null)
{
if (text == null)
{
throw new ArgumentNullException("text");
}
return new TextAndVersion(text, version, filePath);
}
/// <summary>
/// Creates a TextLoader from a SourceTextContainer and version.
///
/// The text obtained from the loader will be the current text of the container at the time
/// the loader is accessed.
/// </summary>
public static TextLoader From(SourceTextContainer container, VersionStamp version, string filePath = null)
{
if (container == null)
{
throw new ArgumentNullException("container");
}
return new TextContainerLoader(container, version, filePath);
}
public static TreeAndVersion Create(SyntaxTree tree, VersionStamp version)
{
if (tree == null)
{
throw new ArgumentNullException("tree");
}
return new TreeAndVersion(tree, version);
}
public static bool CanReusePersistedDependentSemanticVersion(
this Project project, VersionStamp dependentProjectVersion, VersionStamp dependentSemanticVersion, VersionStamp persistedVersion)
{
var canReuse = CanReusePersistedSemanticVersionInternal(
project, dependentProjectVersion, dependentSemanticVersion, persistedVersion, (s, p, v) => s.GetInitialDependentProjectVersionFromDependentSemanticVersion(p, v));
PersistedVersionStampLogger.LogPersistedDependentSemanticVersionUsage(canReuse);
return canReuse;
}
internal static MetadataReference GetOrBuildReference(
Solution solution,
ProjectReference projectReference,
Compilation finalCompilation,
VersionStamp version,
CancellationToken cancellationToken)
{
MetadataReference reference;
if (TryGetReference(solution, projectReference, finalCompilation, version, out reference))
{
return reference;
}
// okay, we don't have one. so create one now.
// first, prepare image
// * NOTE * image is cancellable, do not create it inside of conditional weak table.
var service = solution.Workspace.Services.GetService<ITemporaryStorageService>();
var image = MetadataOnlyImage.Create(service, finalCompilation, cancellationToken);
if (image.IsEmpty)
{
// unfortunately, we couldn't create one. do best effort
if (TryGetReference(solution, projectReference, finalCompilation, VersionStamp.Default, out reference))
{
// we have one from previous compilation!!, it might be out-of-date big time, but better than nothing.
// re-use it
return reference;
}
}
// okay, proceed with whatever image we have
// now, remove existing set
var mapFromBranch = s_cache.GetValue(solution.BranchId, s_createReferenceSetMap);
mapFromBranch.Remove(projectReference.ProjectId);
// create new one
var newReferenceSet = new MetadataOnlyReferenceSet(version, image);
var referenceSet = s_snapshotCache.GetValue(finalCompilation, _ => newReferenceSet);
if (newReferenceSet != referenceSet)
{
// someone else has beaten us.
// let image go eagerly. otherwise, finalizer in temporary storage will take care of it
image.Cleanup();
// return new reference
return referenceSet.GetMetadataReference(finalCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes);
}
// record it to version based cache as well. snapshot cache always has a higher priority. we don't need to check returned set here
// since snapshot based cache will take care of same compilation for us.
mapFromBranch.GetValue(projectReference.ProjectId, _ => referenceSet);
// return new reference
return referenceSet.GetMetadataReference(finalCompilation, projectReference.Aliases, projectReference.EmbedInteropTypes);
}
public void Touch(DiagnosticAnalyzer analyzer, Document document, VersionStamp version)
{
// only touch and updateMemberRange methods are allowed to update the dictionaries
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
Touch_NoLock(data, analyzer, document, version);
}
}
public SyntaxTreeIdentifierInfo(
VersionStamp version,
BloomFilter identifierFilter,
BloomFilter escapedIdentifierFilter) :
base(version)
{
_version = version;
_identifierFilter = identifierFilter ?? throw new ArgumentNullException(nameof(identifierFilter));
_escapedIdentifierFilter = escapedIdentifierFilter ?? throw new ArgumentNullException(nameof(escapedIdentifierFilter));
}
public void Touch(ProviderId providerId, Document document, VersionStamp version)
{
// only touch and updateMemberRange methods are allowed to update the dictionaries
var data = _map.GetOrAdd(document.Id, s_createMap);
lock (data)
{
Touch_NoLock(data, providerId, document, version);
}
}
public ProjectChecksumObjectInfo(ProjectId id, VersionStamp version, string name, string assemblyName, string language, string filePath, string outputFilePath)
{
Id = id;
Version = version;
Name = name;
AssemblyName = assemblyName;
Language = language;
FilePath = filePath;
OutputFilePath = outputFilePath;
}
private ProjectInfo(
ProjectId id,
VersionStamp version,
string name,
string assemblyName,
string language,
string filePath,
string outputFilePath,
// CompilationOptions compilationOptions,
// ParseOptions parseOptions,
// IEnumerable<DocumentInfo> documents,
IEnumerable<ProjectReference> projectReferences,
// IEnumerable<MetadataReference> metadataReferences,
// IEnumerable<AnalyzerReference> analyzerReferences,
// IEnumerable<DocumentInfo> additionalDocuments,
bool isSubmission,
Type hostObjectType)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
if (assemblyName == null)
{
throw new ArgumentNullException("assemblyName");
}
if (language == null)
{
throw new ArgumentNullException("language");
}
this.Id = id;
this.Version = version;
this.Name = name;
this.AssemblyName = assemblyName;
this.Language = language;
this.FilePath = filePath;
this.OutputFilePath = outputFilePath;
// this.CompilationOptions = compilationOptions;
// this.ParseOptions = parseOptions;
// this.Documents = documents.ToImmutableReadOnlyListOrEmpty();
this.ProjectReferences = (projectReferences != null) ? projectReferences.ToList() : new List<ProjectReference>();
// this.MetadataReferences = metadataReferences.ToImmutableReadOnlyListOrEmpty();
// this.AnalyzerReferences = analyzerReferences.ToImmutableReadOnlyListOrEmpty();
// this.AdditionalDocuments = additionalDocuments.ToImmutableReadOnlyListOrEmpty();
this.IsSubmission = isSubmission;
this.HostObjectType = hostObjectType;
}
public Builder(Project project, VersionStamp version)
{
_project = project;
_version = version;
_lazySet = null;
_lazySyntaxLocals = null;
_lazySemanticLocals = null;
_lazyNonLocals = null;
_lazyOthers = null;
}
private static bool TryReadVersion(ObjectReader reader, string formatVersion, out VersionStamp version)
{
version = VersionStamp.Default;
if (reader.ReadString() != formatVersion)
{
return false;
}
version = VersionStamp.ReadFrom(reader);
return true;
}
public TestHostSolution(params TestHostProject[] projects)
{
this.Id = SolutionId.CreateNewId();
this.Version = VersionStamp.Create();
this.Projects = projects;
foreach (var project in projects)
{
project.SetSolution(this);
}
}
private SymbolTreeInfo(
VersionStamp version,
string concatenatedNames,
Node[] sortedNodes,
Task<SpellChecker> spellCheckerTask,
OrderPreservingMultiDictionary<string, string> inheritanceMap)
: this(version, concatenatedNames, sortedNodes, spellCheckerTask)
{
var indexBasedInheritanceMap = CreateIndexBasedInheritanceMap(inheritanceMap);
_inheritanceMap = indexBasedInheritanceMap;
}
private SyntaxTreeIndex(
VersionStamp version,
IdentifierInfo identifierInfo,
ContextInfo contextInfo,
DeclarationInfo declarationInfo)
{
Version = version;
_identifierInfo = identifierInfo;
_contextInfo = contextInfo;
_declarationInfo = declarationInfo;
}
private SolutionInfo(
SolutionId id,
VersionStamp version,
string filePath,
IEnumerable<ProjectInfo> projects)
{
this.Id = id;
this.Version = version;
this.FilePath = filePath;
this.Projects = projects.ToImmutableReadOnlyListOrEmpty();
}
private SymbolTreeInfo(VersionStamp version, IReadOnlyList <Node> orderedNodes)
{
_version = version;
_nodes = orderedNodes;
}
private void UpdateProject(ProjectFileInfo projectFileInfo)
{
var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId);
var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id);
foreach (var file in projectFileInfo.SourceFiles)
{
if (unusedDocuments.Remove(file))
{
continue;
}
using (var stream = File.OpenRead(file))
{
var sourceText = SourceText.From(stream, encoding: Encoding.UTF8);
var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId);
var version = VersionStamp.Create();
var loader = TextLoader.From(TextAndVersion.Create(sourceText, version));
_workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader));
}
}
if (projectFileInfo.SpecifiedLanguageVersion.HasValue)
{
var parseOptions = new CSharpParseOptions(projectFileInfo.SpecifiedLanguageVersion.Value);
_workspace.SetParseOptions(project.Id, parseOptions);
}
foreach (var unused in unusedDocuments)
{
_workspace.RemoveDocument(unused.Value);
}
var unusedProjectReferences = new HashSet <ProjectReference>(project.ProjectReferences);
foreach (var projectReferencePath in projectFileInfo.ProjectReferences)
{
ProjectFileInfo projectReferenceInfo;
if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo))
{
var reference = new ProjectReference(projectReferenceInfo.WorkspaceId);
if (unusedProjectReferences.Remove(reference))
{
// This reference already exists
continue;
}
_workspace.AddProjectReference(project.Id, reference);
}
else
{
_logger.WriteWarning($"Unable to resolve project reference '{projectReferencePath}' for '{projectFileInfo}'.");
}
}
foreach (var unused in unusedProjectReferences)
{
_workspace.RemoveProjectReference(project.Id, unused);
}
var unusedAnalyzers = new Dictionary <string, AnalyzerReference>(project.AnalyzerReferences.ToDictionary(a => a.FullPath));
foreach (var analyzerPath in projectFileInfo.Analyzers)
{
if (!File.Exists(analyzerPath))
{
_logger.WriteWarning($"Unable to resolve assembly '{analyzerPath}'");
}
else
{
if (unusedAnalyzers.Remove(analyzerPath))
{
continue;
}
#if ASPNET50
var analyzerReference = new AnalyzerFileReference(analyzerPath);
project.AddAnalyzerReference(analyzerReference);
#endif
}
}
foreach (var analyzerReference in unusedAnalyzers.Values)
{
project.RemoveAnalyzerReference(analyzerReference);
}
var unusedReferences = new HashSet <MetadataReference>(project.MetadataReferences);
foreach (var referencePath in projectFileInfo.References)
{
if (!File.Exists(referencePath))
{
_logger.WriteWarning($"Unable to resolve assembly '{referencePath}'");
}
else
{
var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath);
if (unusedReferences.Remove(metadataReference))
{
continue;
}
_logger.WriteVerbose($"Adding reference '{referencePath}' to '{projectFileInfo.ProjectFilePath}'.");
_workspace.AddMetadataReference(project.Id, metadataReference);
}
}
foreach (var reference in unusedReferences)
{
_workspace.RemoveMetadataReference(project.Id, reference);
}
}
private async Task <ProjectId> LoadProjectAsync(string projectFilePath, IProjectFileLoader loader, bool preferMetadata, LoadState loadedProjects, CancellationToken cancellationToken)
{
Debug.Assert(projectFilePath != null);
Debug.Assert(loader != null);
var projectId = loadedProjects.GetOrCreateProjectId(projectFilePath);
var projectName = Path.GetFileNameWithoutExtension(projectFilePath);
var projectFile = await loader.LoadProjectFileAsync(projectFilePath, _properties, cancellationToken).ConfigureAwait(false);
var projectFileInfo = await projectFile.GetProjectFileInfoAsync(cancellationToken).ConfigureAwait(false);
var projectDirectory = Path.GetDirectoryName(projectFilePath);
var outputFilePath = projectFileInfo.OutputFilePath;
var outputDirectory = Path.GetDirectoryName(outputFilePath);
VersionStamp version;
if (!string.IsNullOrEmpty(projectFilePath) && File.Exists(projectFilePath))
{
version = VersionStamp.Create(File.GetLastWriteTimeUtc(projectFilePath));
}
else
{
version = VersionStamp.Create();
}
// translate information from command line args
var commandLineParser = _workspace.Services.GetLanguageServices(loader.Language).GetService <ICommandLineParserService>();
var metadataService = _workspace.Services.GetService <IMetadataService>();
var analyzerService = _workspace.Services.GetService <IAnalyzerService>();
var commandLineArgs = commandLineParser.Parse(
arguments: projectFileInfo.CommandLineArgs,
baseDirectory: projectDirectory,
isInteractive: false,
sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory());
var resolver = new RelativePathReferenceResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory);
var metadataReferences = commandLineArgs.ResolveMetadataReferences(new AssemblyReferenceResolver(resolver, metadataService.GetProvider()));
var analyzerLoader = analyzerService.GetLoader();
foreach (var path in commandLineArgs.AnalyzerReferences.Select(r => r.FilePath))
{
analyzerLoader.AddDependencyLocation(path);
}
var analyzerReferences = commandLineArgs.ResolveAnalyzerReferences(analyzerLoader);
var defaultEncoding = commandLineArgs.Encoding;
// docs & additional docs
var docFileInfos = projectFileInfo.Documents.ToImmutableArrayOrEmpty();
var additionalDocFileInfos = projectFileInfo.AdditionalDocuments.ToImmutableArrayOrEmpty();
// check for duplicate documents
var allDocFileInfos = docFileInfos.AddRange(additionalDocFileInfos);
CheckDocuments(allDocFileInfos, projectFilePath, projectId);
var docs = new List <DocumentInfo>();
foreach (var docFileInfo in docFileInfos)
{
string name;
ImmutableArray <string> folders;
GetDocumentNameAndFolders(docFileInfo.LogicalPath, out name, out folders);
docs.Add(DocumentInfo.Create(
DocumentId.CreateNewId(projectId, debugName: docFileInfo.FilePath),
name,
folders,
projectFile.GetSourceCodeKind(docFileInfo.FilePath),
new FileTextLoader(docFileInfo.FilePath, defaultEncoding),
docFileInfo.FilePath,
docFileInfo.IsGenerated));
}
var additionalDocs = new List <DocumentInfo>();
foreach (var docFileInfo in additionalDocFileInfos)
{
string name;
ImmutableArray <string> folders;
GetDocumentNameAndFolders(docFileInfo.LogicalPath, out name, out folders);
additionalDocs.Add(DocumentInfo.Create(
DocumentId.CreateNewId(projectId, debugName: docFileInfo.FilePath),
name,
folders,
SourceCodeKind.Regular,
new FileTextLoader(docFileInfo.FilePath, defaultEncoding),
docFileInfo.FilePath,
docFileInfo.IsGenerated));
}
// project references
var resolvedReferences = await this.ResolveProjectReferencesAsync(
projectId, projectFilePath, projectFileInfo.ProjectReferences, preferMetadata, loadedProjects, cancellationToken).ConfigureAwait(false);
// add metadata references for project refs converted to metadata refs
metadataReferences = metadataReferences.Concat(resolvedReferences.MetadataReferences);
// if the project file loader couldn't figure out an assembly name, make one using the project's file path.
var assemblyName = commandLineArgs.CompilationName;
if (string.IsNullOrWhiteSpace(assemblyName))
{
assemblyName = Path.GetFileNameWithoutExtension(projectFilePath);
// if this is still unreasonable, use a fixed name.
if (string.IsNullOrWhiteSpace(assemblyName))
{
assemblyName = "assembly";
}
}
// make sure that doc-comments at least get parsed.
var parseOptions = commandLineArgs.ParseOptions;
if (parseOptions.DocumentationMode == DocumentationMode.None)
{
parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Parse);
}
// add all the extra options that are really behavior overrides
var compOptions = commandLineArgs.CompilationOptions
.WithXmlReferenceResolver(new XmlFileResolver(projectDirectory))
.WithSourceReferenceResolver(new SourceFileResolver(ImmutableArray <string> .Empty, projectDirectory))
.WithMetadataReferenceResolver(
new AssemblyReferenceResolver(
new RelativePathReferenceResolver(ImmutableArray <string> .Empty, projectDirectory),
MetadataFileReferenceProvider.Default))
.WithStrongNameProvider(new DesktopStrongNameProvider(ImmutableArray.Create(projectDirectory, outputFilePath)))
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
loadedProjects.Add(
ProjectInfo.Create(
projectId,
version,
projectName,
assemblyName,
loader.Language,
projectFilePath,
outputFilePath,
compilationOptions: compOptions,
parseOptions: parseOptions,
documents: docs,
projectReferences: resolvedReferences.ProjectReferences,
metadataReferences: metadataReferences,
analyzerReferences: analyzerReferences,
additionalDocuments: additionalDocs,
isSubmission: false,
hostObjectType: null));
return(projectId);
}
public Data(VersionStamp textVersion, VersionStamp syntaxVersion, ImmutableArray <TodoItem> items)
{
this.TextVersion = textVersion;
this.SyntaxVersion = syntaxVersion;
this.Items = items;
}
public VersionArgument(VersionStamp textVersion, VersionStamp dataVersion) :
this(textVersion, dataVersion, VersionStamp.Default)
{
}
public VersionArgument(VersionStamp textVersion, VersionStamp dataVersion, VersionStamp projectVersion)
{
this.TextVersion = textVersion;
this.DataVersion = dataVersion;
this.ProjectVersion = projectVersion;
}
public SyntaxModel(Workspace workspace, Document document, SemanticModel semanticModel, CompilationUnitSyntax compilation, VersionStamp version)
{
Workspace = workspace;
Document = document;
SemanticModel = semanticModel;
Compilation = compilation;
Version = version;
}
public static DiagnosticAnalysisResultMap <DiagnosticAnalyzer, DiagnosticAnalysisResult> ReadDiagnosticAnalysisResults(
ObjectReader reader, IDictionary <string, DiagnosticAnalyzer> analyzerMap, Project project, VersionStamp version, CancellationToken cancellationToken)
{
var diagnosticDataSerializer = new DiagnosticDataSerializer(VersionStamp.Default, VersionStamp.Default);
var analysisMap = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, DiagnosticAnalysisResult>();
var analysisCount = reader.ReadInt32();
for (var i = 0; i < analysisCount; i++)
{
var analyzer = analyzerMap[reader.ReadString()];
var syntaxLocalMap = ReadDiagnosticDataMap(reader, diagnosticDataSerializer, project, cancellationToken);
var semanticLocalMap = ReadDiagnosticDataMap(reader, diagnosticDataSerializer, project, cancellationToken);
var nonLocalMap = ReadDiagnosticDataMap(reader, diagnosticDataSerializer, project, cancellationToken);
var others = diagnosticDataSerializer.ReadDiagnosticData(reader, project, document: null, cancellationToken);
var analysisResult = DiagnosticAnalysisResult.Create(
project,
version,
syntaxLocalMap,
semanticLocalMap,
nonLocalMap,
others.NullToEmpty(),
documentIds: null);
analysisMap.Add(analyzer, analysisResult);
}
var telemetryMap = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, AnalyzerTelemetryInfo>();
var telemetryCount = reader.ReadInt32();
for (var i = 0; i < telemetryCount; i++)
{
var analyzer = analyzerMap[reader.ReadString()];
var telemetryInfo = ReadTelemetry(reader, cancellationToken);
telemetryMap.Add(analyzer, telemetryInfo);
}
return(DiagnosticAnalysisResultMap.Create(analysisMap.ToImmutable(), telemetryMap.ToImmutable()));
}
private static AnalysisResult GetResultOrEmpty(ImmutableDictionary <DiagnosticAnalyzer, AnalysisResult> map, DiagnosticAnalyzer analyzer, ProjectId projectId, VersionStamp version)
{
AnalysisResult result;
if (map.TryGetValue(analyzer, out result))
{
return(result);
}
return(new AnalysisResult(projectId, version));
}
internal override TextAndVersion LoadTextAndVersionSynchronously(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken)
{
return(TextAndVersion.Create(_text, VersionStamp.Create()));
}
internal static Solution CreateFullSolution(Workspace workspace)
{
var solution = workspace.CurrentSolution;
var languages = ImmutableHashSet.Create(LanguageNames.CSharp, LanguageNames.VisualBasic);
var solutionOptions = solution.Workspace.Services.GetRequiredService <IOptionService>().GetSerializableOptionsSnapshot(languages);
solution = solution.WithOptions(solutionOptions);
var csCode = "class A { }";
var project1 = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp);
var document1 = project1.AddDocument("Document1", SourceText.From(csCode));
var vbCode = "Class B\r\nEnd Class";
var project2 = document1.Project.Solution.AddProject("Project2", "Project2.dll", LanguageNames.VisualBasic);
var document2 = project2.AddDocument("Document2", SourceText.From(vbCode));
solution = document2.Project.Solution.GetRequiredProject(project1.Id)
.AddProjectReference(new ProjectReference(project2.Id, ImmutableArray.Create("test")))
.AddMetadataReference(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
.AddAnalyzerReference(new AnalyzerFileReference(Path.Combine(TempRoot.Root, "path1"), new TestAnalyzerAssemblyLoader()))
.AddAdditionalDocument("Additional", SourceText.From("hello"), ImmutableArray.Create("test"), @".\Add").Project.Solution;
return(solution
.WithAnalyzerReferences(new[] { new AnalyzerFileReference(Path.Combine(TempRoot.Root, "path2"), new TestAnalyzerAssemblyLoader()) })
.AddAnalyzerConfigDocuments(
ImmutableArray.Create(
DocumentInfo.Create(
DocumentId.CreateNewId(project1.Id),
".editorconfig",
loader: TextLoader.From(TextAndVersion.Create(SourceText.From("root = true"), VersionStamp.Create()))))));
}
public WorkspaceSnapshot(VersionStamp version, ImmutableDictionary <string, DocumentSnapshot> documents)
{
Version = version;
Documents = documents;
}
public static DiagnosticAnalysisResultMap <DiagnosticAnalyzer, DiagnosticAnalysisResult> Deserialize(
ObjectReader reader, IDictionary <string, DiagnosticAnalyzer> analyzerMap, Project project, VersionStamp version, CancellationToken cancellationToken)
{
var diagnosticDataSerializer = new DiagnosticDataSerializer(VersionStamp.Default, VersionStamp.Default);
var analysisMap = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, DiagnosticAnalysisResult>();
var analysisCount = reader.ReadInt32();
for (var i = 0; i < analysisCount; i++)
{
var analyzer = analyzerMap[reader.ReadString()];
var syntaxLocalMap = Deserialize(reader, diagnosticDataSerializer, project, cancellationToken);
var semanticLocalMap = Deserialize(reader, diagnosticDataSerializer, project, cancellationToken);
var nonLocalMap = Deserialize(reader, diagnosticDataSerializer, project, cancellationToken);
var others = diagnosticDataSerializer.ReadFrom(reader, project, cancellationToken);
var analysisResult = DiagnosticAnalysisResult.CreateFromSerialization(
project,
version,
syntaxLocalMap,
semanticLocalMap,
nonLocalMap,
GetOrDefault(others));
analysisMap.Add(analyzer, analysisResult);
}
var telemetryMap = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, AnalyzerTelemetryInfo>();
var telemetryCount = reader.ReadInt32();
for (var i = 0; i < telemetryCount; i++)
{
var analyzer = analyzerMap[reader.ReadString()];
var telemetryInfo = Deserialize(reader, cancellationToken);
telemetryMap.Add(analyzer, telemetryInfo);
}
var exceptionMap = ImmutableDictionary.CreateBuilder <DiagnosticAnalyzer, ImmutableArray <DiagnosticData> >();
var exceptionCount = reader.ReadInt32();
for (var i = 0; i < exceptionCount; i++)
{
var analyzer = analyzerMap[reader.ReadString()];
var exceptions = diagnosticDataSerializer.ReadFrom(reader, project, cancellationToken);
exceptionMap.Add(analyzer, GetOrDefault(exceptions));
}
return(DiagnosticAnalysisResultMap.Create(analysisMap.ToImmutable(), telemetryMap.ToImmutable(), exceptionMap.ToImmutable()));
}
public AnalysisData(VersionStamp textVersion, VersionStamp dataVersion, ImmutableArray <DiagnosticData> oldItems, ImmutableArray <DiagnosticData> newItems) :
this(textVersion, dataVersion, newItems)
{
this.OldItems = oldItems;
}
public override bool TryGetTextVersion(out VersionStamp result)
{
return(State.TryGetTextVersion(out result));
}
async Task InitializeAsync(ITextBuffer buffer, string code, MetadataReference[] refs, string languageName, ISynchronousTagger <IClassificationTag> tagger, CompilationOptions compilationOptions, ParseOptions parseOptions)
{
using (var workspace = new AdhocWorkspace(RoslynMefHostServices.DefaultServices)) {
var documents = new List <DocumentInfo>();
var projectId = ProjectId.CreateNewId();
documents.Add(DocumentInfo.Create(DocumentId.CreateNewId(projectId), "main.cs", null, SourceCodeKind.Regular, TextLoader.From(buffer.AsTextContainer(), VersionStamp.Create())));
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "compilecodeproj", Guid.NewGuid().ToString(), languageName,
compilationOptions: compilationOptions
.WithOptimizationLevel(OptimizationLevel.Release)
.WithPlatform(Platform.AnyCpu)
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default),
parseOptions: parseOptions,
documents: documents,
metadataReferences: refs,
isSubmission: false, hostObjectType: null);
workspace.AddProject(projectInfo);
foreach (var doc in documents)
{
workspace.OpenDocument(doc.Id);
}
buffer.Replace(new Span(0, buffer.CurrentSnapshot.Length), code);
{
// Initialize classification code paths
var spans = new NormalizedSnapshotSpanCollection(new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length));
foreach (var tagSpan in tagger.GetTags(spans, CancellationToken.None))
{
}
}
{
// Initialize completion code paths
var info = CompletionInfo.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
var completionTrigger = CompletionTrigger.Default;
var completionList = await info.Value.CompletionService.GetCompletionsAsync(info.Value.Document, 0, completionTrigger);
}
}
{
// Initialize signature help code paths
var info = SignatureHelpInfo.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
int sigHelpIndex = code.IndexOf("sighelp");
Debug.Assert(sigHelpIndex >= 0);
var triggerInfo = new SignatureHelpTriggerInfo(SignatureHelpTriggerReason.InvokeSignatureHelpCommand);
var items = await info.Value.SignatureHelpService.GetItemsAsync(info.Value.Document, sigHelpIndex, triggerInfo);
}
}
{
// Initialize quick info code paths
var info = QuickInfoState.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
int quickInfoIndex = code.IndexOf("Equals");
Debug.Assert(quickInfoIndex >= 0);
var item = await info.Value.QuickInfoService.GetItemAsync(info.Value.Document, quickInfoIndex);
}
}
}
}
public AnalysisData(VersionStamp textVersion, VersionStamp dataVersion, ImmutableArray <DiagnosticData> items)
{
this.TextVersion = textVersion;
this.DataVersion = dataVersion;
this.Items = items;
}
private static bool CheckVersions(Document document, VersionStamp textVersion, VersionStamp syntaxVersion, Data existingData)
{
// first check full version to see whether we can reuse data in same session, if we can't, check timestamp only version to see whether
// we can use it cross-session.
return(document.CanReusePersistedTextVersion(textVersion, existingData.TextVersion) &&
document.CanReusePersistedSyntaxTreeVersion(syntaxVersion, existingData.SyntaxVersion));
}
public ProjectBuildChangeTriggerTest()
{
SomeProject = new HostProject("c:\\SomeProject\\SomeProject.csproj", FallbackRazorConfiguration.MVC_1_0, "SomeProject");
SomeOtherProject = new HostProject("c:\\SomeOtherProject\\SomeOtherProject.csproj", FallbackRazorConfiguration.MVC_2_0, "SomeOtherProject");
Workspace = TestWorkspace.Create(w => SomeWorkspaceProject = w.AddProject(ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"SomeProject",
"SomeProject",
LanguageNames.CSharp,
filePath: SomeProject.FilePath)));
}
private async Task <Solution> CreateSolutionAsync(Checksum solutionChecksum, CancellationToken cancellationToken)
{
// synchronize whole solution first
await _assetService.SynchronizeSolutionAssetsAsync(solutionChecksum, cancellationToken).ConfigureAwait(false);
var solutionChecksumObject = await _assetService.GetAssetAsync <SolutionStateChecksums>(solutionChecksum, cancellationToken).ConfigureAwait(false);
var workspace = new AdhocWorkspace(RoslynServices.HostServices, workspaceKind: WorkspaceKind_RemoteWorkspace);
// never cache any tree in memory
workspace.Options = workspace.Options.WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0);
var solutionInfo = await _assetService.GetAssetAsync <SolutionInfo.SolutionAttributes>(solutionChecksumObject.Info, cancellationToken).ConfigureAwait(false);
var projects = new List <ProjectInfo>();
foreach (var projectChecksum in solutionChecksumObject.Projects)
{
var projectSnapshot = await _assetService.GetAssetAsync <ProjectStateChecksums>(projectChecksum, cancellationToken).ConfigureAwait(false);
var projectInfo = await _assetService.GetAssetAsync <ProjectInfo.ProjectAttributes>(projectSnapshot.Info, cancellationToken).ConfigureAwait(false);
if (!workspace.Services.IsSupported(projectInfo.Language))
{
// only add project our workspace supports.
// workspace doesn't allow creating project with unknown languages
continue;
}
var documents = new List <DocumentInfo>();
foreach (var documentChecksum in projectSnapshot.Documents)
{
var documentSnapshot = await _assetService.GetAssetAsync <DocumentStateChecksums>(documentChecksum, cancellationToken).ConfigureAwait(false);
var documentInfo = await _assetService.GetAssetAsync <DocumentInfo.DocumentAttributes>(documentSnapshot.Info, cancellationToken).ConfigureAwait(false);
var textLoader = TextLoader.From(
TextAndVersion.Create(
new ChecksumSourceText(
documentSnapshot.Text,
await _assetService.GetAssetAsync <SourceText>(documentSnapshot.Text, cancellationToken).ConfigureAwait(false)),
VersionStamp.Create(),
documentInfo.FilePath));
// TODO: do we need version?
documents.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
textLoader,
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var p2p = new List <ProjectReference>();
foreach (var checksum in projectSnapshot.ProjectReferences)
{
cancellationToken.ThrowIfCancellationRequested();
var reference = await _assetService.GetAssetAsync <ProjectReference>(checksum, cancellationToken).ConfigureAwait(false);
p2p.Add(reference);
}
var metadata = new List <MetadataReference>();
foreach (var checksum in projectSnapshot.MetadataReferences)
{
cancellationToken.ThrowIfCancellationRequested();
var reference = await _assetService.GetAssetAsync <MetadataReference>(checksum, cancellationToken).ConfigureAwait(false);
metadata.Add(reference);
}
var analyzers = new List <AnalyzerReference>();
foreach (var checksum in projectSnapshot.AnalyzerReferences)
{
cancellationToken.ThrowIfCancellationRequested();
var reference = await _assetService.GetAssetAsync <AnalyzerReference>(checksum, cancellationToken).ConfigureAwait(false);
analyzers.Add(reference);
}
var additionals = new List <DocumentInfo>();
foreach (var documentChecksum in projectSnapshot.AdditionalDocuments)
{
cancellationToken.ThrowIfCancellationRequested();
var documentSnapshot = await _assetService.GetAssetAsync <DocumentStateChecksums>(documentChecksum, cancellationToken).ConfigureAwait(false);
var documentInfo = await _assetService.GetAssetAsync <DocumentInfo.DocumentAttributes>(documentSnapshot.Info, cancellationToken).ConfigureAwait(false);
var textLoader = TextLoader.From(
TextAndVersion.Create(
new ChecksumSourceText(
documentSnapshot.Text,
await _assetService.GetAssetAsync <SourceText>(documentSnapshot.Text, cancellationToken).ConfigureAwait(false)),
VersionStamp.Create(),
documentInfo.FilePath));
// TODO: do we need version?
additionals.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
textLoader,
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var compilationOptions = await _assetService.GetAssetAsync <CompilationOptions>(projectSnapshot.CompilationOptions, cancellationToken).ConfigureAwait(false);
var parseOptions = await _assetService.GetAssetAsync <ParseOptions>(projectSnapshot.ParseOptions, cancellationToken).ConfigureAwait(false);
projects.Add(
ProjectInfo.Create(
projectInfo.Id, projectInfo.Version, projectInfo.Name, projectInfo.AssemblyName,
projectInfo.Language, projectInfo.FilePath, projectInfo.OutputFilePath,
compilationOptions, parseOptions,
documents, p2p, metadata, analyzers, additionals, projectInfo.IsSubmission));
}
return(workspace.AddSolution(SolutionInfo.Create(solutionInfo.Id, solutionInfo.Version, solutionInfo.FilePath, projects)));
}
protected AbstractSyntaxTreeInfo(VersionStamp version)
: base(version)
{
}
private async Task <int> OnExecuteAsync(CommandLineApplication app,
CancellationToken cancellationToken = default)
{
var outputDir = Path.IsPathFullyQualified(OutputProjectDir)
? OutputProjectDir
: Path.GetFullPath(OutputProjectDir);
Directory.CreateDirectory(outputDir);
var workspace = new AdhocWorkspace();
var projectId = ProjectId.CreateNewId();
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "XP.SDK", "XP.SDK", LanguageNames.CSharp)
.WithDefaultNamespace("XP.SDK");
var project = workspace.AddProject(projectInfo);
var typeMap = new TypeMap(BuildTypeCallback);
_enumBuilder = new EnumBuilder(workspace, projectId, outputDir, typeMap)
.Map("xpMainWindowStyle_MainWindow", "MainWindowType")
.Map("xpProperty_MainWindowType", "MainWindowProperty")
.Map("xpMessage_CloseButtonPushed", "MainWindowMessage")
.Map("xpSubWindowStyle_SubWindow", "SubWindowType")
.Map("xpProperty_SubWindowType", "SubWindowProperty")
.Map("xpPushButton", "ButtonType")
.Map("xpButtonBehaviorPushButton", "ButtonBehavior")
.Map("xpProperty_ButtonType", "ButtonProperty")
.Map("xpMsg_PushButtonPressed", "ButtonMessage")
.Map("xpTextEntryField", "TextFieldType")
.Map("xpProperty_EditFieldSelStart", "TextFieldProperty")
.Map("xpMsg_TextFieldChanged", "TextFieldMessage")
.Map("xpScrollBarTypeScrollBar", "ScrollBarType")
.Map("xpProperty_ScrollBarSliderPosition", "ScrollBarProperty")
.Map("xpMsg_ScrollBarSliderPositionChanged", "ScrollBarMessage")
.Map("xpProperty_CaptionLit", "CaptionProperty")
.Map("xpShip", "GeneralGraphicsType")
.Map("xpProperty_GeneralGraphicsType", "GeneralGraphicsProperty")
.Map("xpProperty_ProgressPosition", "ProgressBarProperty");
_handleBuilder = new HandleBuilder(workspace, projectId, outputDir, typeMap);
_delegateBuilder = new DelegateBuilder(workspace, projectId, outputDir, typeMap);
_structBuilder = new StructBuilder(workspace, projectId, outputDir, typeMap);
var functionBuilder = new FunctionBuilder(workspace, projectId, outputDir, typeMap);
var xplmHeadersPath = Path.Combine(SdkRoot, "CHeaders", "XPLM");
if (!Directory.Exists(xplmHeadersPath))
{
throw new DirectoryNotFoundException($"Directory '{xplmHeadersPath}' does not exist.");
}
var xmplHeaders = Directory.EnumerateFiles(xplmHeadersPath, "*.h");
var xpWidgetsHeadersPath = Path.Combine(SdkRoot, "CHeaders", "Widgets");
if (!Directory.Exists(xpWidgetsHeadersPath))
{
throw new DirectoryNotFoundException($"Directory '{xpWidgetsHeadersPath}' does not exist.");
}
var xpWidgetsHeaders = Directory.EnumerateFiles(xpWidgetsHeadersPath, "*.h");
var headers = xmplHeaders.Concat(xpWidgetsHeaders)
/*.Where(x => Path.GetFileName(x) != "XPStandardWidgets.h")*/;
var parserOptions = new CppParserOptions
{
Defines = { "IBM", "XPLM303", "XPLM302", "XPLM301", "XPLM300", "XPLM210", "XPLM200" },
ParseSystemIncludes = false,
TargetCpu = CppTargetCpu.X86_64,
IncludeFolders = { xplmHeadersPath },
};
var compilation = CppParser.ParseFiles(headers.ToList(), parserOptions);
foreach (var child in compilation.Children().OfType <CppType>())
{
await BuildTypeAsync(child);
}
var functionsByHeader = compilation
.Functions
.ToLookup(x => x.Span.Start.File);
foreach (var functionsInHeader in functionsByHeader)
{
await functionBuilder.BuildAsync(functionsInHeader);
}
foreach (var document in workspace.CurrentSolution.Projects.SelectMany(p => p.Documents))
{
var text = await document.GetTextAsync(cancellationToken);
await using var writer = new StreamWriter(document.FilePath, false);
text.Write(writer, cancellationToken);
}
return(0);
async Task BuildTypeCallback(dynamic item)
{
using (Log.PushIdent())
{
await BuildTypeAsync(item);
}
}
}
/// <summary>
/// Loads the <see cref="SolutionInfo"/> for the specified solution file, including all projects referenced by the solution file and
/// all the projects referenced by the project files.
/// </summary>
public async Task <SolutionInfo> LoadSolutionInfoAsync(
string solutionFilePath,
IReadOnlyDictionary <string, ProjectId> projectPathToProjectIdMap = null,
CancellationToken cancellationToken = default(CancellationToken))
{
if (solutionFilePath == null)
{
throw new ArgumentNullException(nameof(solutionFilePath));
}
var absoluteSolutionPath = this.GetAbsoluteSolutionPath(solutionFilePath, Directory.GetCurrentDirectory());
using (_dataGuard.DisposableWait(cancellationToken))
{
this.SetSolutionProperties(absoluteSolutionPath);
}
VersionStamp version = default(VersionStamp);
#if !MSBUILD12
Microsoft.Build.Construction.SolutionFile solutionFile = Microsoft.Build.Construction.SolutionFile.Parse(absoluteSolutionPath);
var reportMode = this.SkipUnrecognizedProjects ? ReportMode.Log : ReportMode.Throw;
// a list to accumulate all the loaded projects
var loadedProjects = new LoadState(null);
// load all the projects
foreach (var project in solutionFile.ProjectsInOrder)
{
cancellationToken.ThrowIfCancellationRequested();
if (project.ProjectType != SolutionProjectType.SolutionFolder)
{
var projectAbsolutePath = TryGetAbsolutePath(project.AbsolutePath, reportMode);
if (projectAbsolutePath != null)
{
IProjectFileLoader loader;
if (TryGetLoaderFromProjectPath(projectAbsolutePath, reportMode, out loader))
{
// projects get added to 'loadedProjects' as side-effect
// never prefer metadata when loading solution, all projects get loaded if they can.
var tmp = await GetOrLoadProjectAsync(projectAbsolutePath, loader, preferMetadata : false, loadedProjects : loadedProjects, cancellationToken : cancellationToken).ConfigureAwait(false);
}
}
}
}
#else
SolutionFile solutionFile = null;
using (var reader = new StreamReader(absoluteSolutionPath))
{
version = VersionStamp.Create(File.GetLastWriteTimeUtc(absoluteSolutionPath));
var text = await reader.ReadToEndAsync().ConfigureAwait(false);
solutionFile = SolutionFile.Parse(new StringReader(text));
}
var solutionFolder = Path.GetDirectoryName(absoluteSolutionPath);
// a list to accumulate all the loaded projects
var loadedProjects = new LoadState(null);
var reportMode = this.SkipUnrecognizedProjects ? ReportMode.Log : ReportMode.Throw;
// load all the projects
foreach (var projectBlock in solutionFile.ProjectBlocks)
{
cancellationToken.ThrowIfCancellationRequested();
string absoluteProjectPath;
if (TryGetAbsoluteProjectPath(projectBlock.ProjectPath, solutionFolder, reportMode, out absoluteProjectPath))
{
IProjectFileLoader loader;
if (TryGetLoaderFromProjectPath(absoluteProjectPath, reportMode, out loader))
{
// projects get added to 'loadedProjects' as side-effect
// never prefer metadata when loading solution, all projects get loaded if they can.
var tmp = await GetOrLoadProjectAsync(absoluteProjectPath, loader, preferMetadata : false, loadedProjects : loadedProjects, cancellationToken : cancellationToken).ConfigureAwait(false);
}
}
}
#endif
// construct workspace from loaded project infos
return(SolutionInfo.Create(SolutionId.CreateNewId(debugName: absoluteSolutionPath), version, absoluteSolutionPath, loadedProjects.Projects));
}
protected static void AnalyzeWithRule <T>(string input, string ruleId, string output = null, int issueToFix = -1, int actionToRun = 0, Action <int, Diagnostic> diagnosticCheck = null) where T : DiagnosticAnalyzer, new()
{
var text = new StringBuilder();
var expectedDiagnosics = new List <TextSpan> ();
int start = -1;
for (int i = 0; i < input.Length; i++)
{
char ch = input [i];
if (ch == '$')
{
if (start < 0)
{
start = text.Length;
continue;
}
expectedDiagnosics.Add(TextSpan.FromBounds(start, text.Length));
start = -1;
}
else
{
text.Append(ch);
}
}
var syntaxTree = CSharpSyntaxTree.ParseText(text.ToString());
Compilation compilation = CreateCompilationWithMscorlib(new [] { syntaxTree });
var diagnostics = new List <Diagnostic>();
var compilationWithAnalyzers = compilation.WithAnalyzers(System.Collections.Immutable.ImmutableArray <DiagnosticAnalyzer> .Empty.Add(new T()));
diagnostics.AddRange(compilationWithAnalyzers.GetAnalyzerDiagnosticsAsync().Result);
if (expectedDiagnosics.Count != diagnostics.Count)
{
Console.WriteLine("Diagnostics: " + diagnostics.Count);
foreach (var diag in diagnostics)
{
Console.WriteLine(diag.Id + "/" + diag.GetMessage());
}
Assert.Fail("Diagnostic count mismatch expected: " + expectedDiagnosics.Count + " but was:" + diagnostics.Count);
}
for (int i = 0; i < expectedDiagnosics.Count; i++)
{
var d = diagnostics [i];
var wholeSpan = GetWholeSpan(d);
if (wholeSpan != expectedDiagnosics [i])
{
Assert.Fail("Diagnostic " + i + " span mismatch expected: " + expectedDiagnosics[i] + " but was " + wholeSpan);
}
if (diagnosticCheck != null)
{
diagnosticCheck(i, d);
}
}
if (output == null)
{
return;
}
var workspace = new TestWorkspace();
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
workspace.Open(ProjectInfo.Create(
projectId,
VersionStamp.Create(),
"", "", LanguageNames.CSharp, null, null, null, null,
new [] {
DocumentInfo.Create(
documentId,
"a.cs",
null,
SourceCodeKind.Regular,
TextLoader.From(TextAndVersion.Create(SourceText.From(text.ToString()), VersionStamp.Create())))
}
));
if (issueToFix < 0)
{
diagnostics.Reverse();
foreach (var v in diagnostics)
{
RunFix(workspace, projectId, documentId, v);
}
}
else
{
RunFix(workspace, projectId, documentId, diagnostics.ElementAt(issueToFix), actionToRun);
}
var txt = workspace.CurrentSolution.GetProject(projectId).GetDocument(documentId).GetTextAsync().Result.ToString();
if (output != txt)
{
Console.WriteLine("expected:");
Console.WriteLine(output);
Console.WriteLine("got:");
Console.WriteLine(txt);
Assert.Fail();
}
}
public void Initalize()
{
var solutionFilePath = _env.SolutionFilePath;
if (string.IsNullOrEmpty(solutionFilePath))
{
var solutions = Directory.GetFiles(_env.Path, "*.sln");
var result = SolutionPicker.ChooseSolution(_env.Path, solutions);
if (result.Message != null)
{
_logger.WriteInformation(result.Message);
}
if (result.Solution == null)
{
return;
}
solutionFilePath = result.Solution;
}
SolutionFile solutionFile = null;
_context.SolutionPath = solutionFilePath;
using (var stream = File.OpenRead(solutionFilePath))
{
using (var reader = new StreamReader(stream))
{
solutionFile = SolutionFile.Parse(reader);
}
}
_logger.WriteInformation($"Detecting projects in '{solutionFilePath}'.");
foreach (var block in solutionFile.ProjectBlocks)
{
if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid))
{
if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid)
{
_logger.WriteWarning("Skipped unsupported project type '{0}'", block.ProjectPath);
continue;
}
}
if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid))
{
continue;
}
var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar))));
_logger.WriteInformation($"Loading project from '{projectFilePath}'.");
var projectFileInfo = CreateProject(projectFilePath);
if (projectFileInfo == null)
{
continue;
}
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name),
VersionStamp.Create(),
projectFileInfo.Name,
projectFileInfo.AssemblyName,
LanguageNames.CSharp,
projectFileInfo.ProjectFilePath);
_workspace.AddProject(projectInfo);
projectFileInfo.WorkspaceId = projectInfo.Id;
_context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo;
_context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id;
_watcher.Watch(projectFilePath, OnProjectChanged);
}
foreach (var projectFileInfo in _context.Projects.Values)
{
UpdateProject(projectFileInfo);
}
}
public void Initalize()
{
_logger.LogInformation($"Detecting CSX files in '{_env.Path}'.");
var allCsxFiles = Directory.GetFiles(_env.Path, "*.csx", SearchOption.TopDirectoryOnly);
if (allCsxFiles.Length == 0)
{
_logger.LogInformation("Could not find any CSX files");
return;
}
_scriptCsContext.Path = _env.Path;
_logger.LogInformation($"Found {allCsxFiles.Length} CSX files.");
//script name is added here as a fake one (dir path not even a real file); this is OK though -> it forces MEF initialization
var scriptServicesBuilder = new ScriptServicesBuilder(new ScriptConsole(), LogManager.GetCurrentClassLogger()).
LogLevel(LogLevel.Info).Cache(false).Repl(false).ScriptName(_env.Path).ScriptEngine <NullScriptEngine>();
_scriptServices = scriptServicesBuilder.Build();
var mscorlib = MetadataReference.CreateFromAssembly(typeof(object).GetTypeInfo().Assembly);
var systemCore = MetadataReference.CreateFromAssembly(typeof(Enumerable).GetTypeInfo().Assembly);
var scriptcsContracts = MetadataReference.CreateFromAssembly(typeof(IScriptHost).Assembly);
var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp6, DocumentationMode.Parse, SourceCodeKind.Script);
var scriptPacks = _scriptServices.ScriptPackResolver.GetPacks().ToList();
var assemblyPaths = _scriptServices.AssemblyResolver.GetAssemblyPaths(_env.Path);
foreach (var csxPath in allCsxFiles)
{
try
{
_scriptCsContext.CsxFiles.Add(csxPath);
var processResult = _scriptServices.FilePreProcessor.ProcessFile(csxPath);
var references = new List <MetadataReference> {
mscorlib, systemCore, scriptcsContracts
};
var usings = new List <string>(ScriptExecutor.DefaultNamespaces);
//default references
ImportReferences(references, ScriptExecutor.DefaultReferences);
//file usings
usings.AddRange(processResult.Namespaces);
//#r references
ImportReferences(references, processResult.References);
//nuget references
ImportReferences(references, assemblyPaths);
//script packs
if (scriptPacks != null && scriptPacks.Any())
{
var scriptPackSession = new ScriptPackSession(scriptPacks, new string[0]);
scriptPackSession.InitializePacks();
//script pack references
ImportReferences(references, scriptPackSession.References);
//script pack usings
usings.AddRange(scriptPackSession.Namespaces);
_scriptCsContext.ScriptPacks.UnionWith(scriptPackSession.Contexts.Select(pack => pack.GetType().ToString()));
}
_scriptCsContext.References.UnionWith(references.Select(x => x.Display));
_scriptCsContext.Usings.UnionWith(usings);
var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, usings: usings.Distinct());
var fileName = Path.GetFileName(csxPath);
var projectId = ProjectId.CreateNewId(Guid.NewGuid().ToString());
var project = ProjectInfo.Create(projectId, VersionStamp.Create(), fileName, $"{fileName}.dll", LanguageNames.CSharp, null, null,
compilationOptions, parseOptions, null, null, references, null, null, true, typeof(IScriptHost));
_workspace.AddProject(project);
AddFile(csxPath, projectId);
foreach (var filePath in processResult.LoadedScripts.Distinct().Except(new[] { csxPath }))
{
_scriptCsContext.CsxFiles.Add(filePath);
var loadedFileName = Path.GetFileName(filePath);
var loadedFileProjectId = ProjectId.CreateNewId(Guid.NewGuid().ToString());
var loadedFileSubmissionProject = ProjectInfo.Create(loadedFileProjectId, VersionStamp.Create(),
$"{loadedFileName}-LoadedFrom-{fileName}", $"{loadedFileName}-LoadedFrom-{fileName}.dll", LanguageNames.CSharp, null, null,
compilationOptions, parseOptions, null, null, references, null, null, true, typeof(IScriptHost));
_workspace.AddProject(loadedFileSubmissionProject);
AddFile(filePath, loadedFileProjectId);
_workspace.AddProjectReference(projectId, new ProjectReference(loadedFileProjectId));
}
}
catch (Exception ex)
{
_logger.LogError($"{csxPath} will be ignored due to the following error:", ex);
}
}
}
static TSymbol FindSymbol <TSymbol>(string code)
where TSymbol : ISymbol
{
var position = code.IndexOf('$');
var cleanedCode = code.Remove(position, 1);
var workspace = new DiagnosticTestBase.TestWorkspace();
var projectId = ProjectId.CreateNewId();
var documentId = DocumentId.CreateNewId(projectId);
var docInfo = DocumentInfo.Create(documentId, "Document1.cs", loader: TextLoader.From(TextAndVersion.Create(SourceText.From(cleanedCode), VersionStamp.Create())));
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var projectInfo = ProjectInfo.Create(
projectId,
VersionStamp.Create(),
"Project",
"Project",
LanguageNames.CSharp,
metadataReferences: new[] { mscorlib },
documents: new[] { docInfo }
);
workspace.Open(projectInfo);
var document = workspace.CurrentSolution.GetDocument(documentId);
var semanticModel = document.GetSemanticModelAsync().Result;
var diag = semanticModel.GetDiagnostics();
Assert.That(diag, Is.Empty, "No errors reported");
var symbol = SymbolFinder.FindSymbolAtPosition(semanticModel, position, workspace);
Assert.That(symbol, Is.Not.Null, "Symbol should be found");
Assert.That(symbol, Is.InstanceOf <TSymbol>());
return((TSymbol)symbol);
}
private void AddFile(string filePath, ProjectId projectId)
{
using (var stream = File.OpenRead(filePath))
using (var reader = new StreamReader(stream))
{
var fileName = Path.GetFileName(filePath);
var csxFile = reader.ReadToEnd();
var documentId = DocumentId.CreateNewId(projectId, fileName);
var documentInfo = DocumentInfo.Create(documentId, fileName, null, SourceCodeKind.Script, null, filePath)
.WithSourceCodeKind(SourceCodeKind.Script)
.WithTextLoader(TextLoader.From(TextAndVersion.Create(SourceText.From(csxFile), VersionStamp.Create())));
_workspace.AddDocument(documentInfo);
}
}
public static TestDocumentSnapshot Create(string filePath, VersionStamp version) => Create(filePath, string.Empty, version);
private async Task <(DiagnosticAnalysisResult loadDiagnostics, ImmutableHashSet <Document>?failedDocuments)> GetDocumentLoadFailuresAsync(Project project, VersionStamp version, CancellationToken cancellationToken)
{
ImmutableHashSet <Document> .Builder?failedDocuments = null;
ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Builder?lazyLoadDiagnostics = null;
foreach (var document in project.Documents)
{
var loadDiagnostic = await document.State.GetLoadDiagnosticAsync(cancellationToken).ConfigureAwait(false);
if (loadDiagnostic != null)
{
lazyLoadDiagnostics ??= ImmutableDictionary.CreateBuilder <DocumentId, ImmutableArray <DiagnosticData> >();
lazyLoadDiagnostics.Add(document.Id, ImmutableArray.Create(DiagnosticData.Create(loadDiagnostic, document)));
failedDocuments ??= ImmutableHashSet.CreateBuilder <Document>();
failedDocuments.Add(document);
}
}
var result = DiagnosticAnalysisResult.Create(
project,
version,
syntaxLocalMap: lazyLoadDiagnostics?.ToImmutable() ?? ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Empty,
semanticLocalMap: ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Empty,
nonLocalMap: ImmutableDictionary <DocumentId, ImmutableArray <DiagnosticData> > .Empty,
others: ImmutableArray <DiagnosticData> .Empty,
documentIds: null);
return(result, failedDocuments?.ToImmutable());
}
