public static void AppendToAliasNameSet( this string?alias, ImmutableHashSet <string> .Builder builder ) { if (RoslynString.IsNullOrWhiteSpace(alias)) { return; } builder.Add(alias); var caseSensitive = builder.KeyComparer == StringComparer.Ordinal; Debug.Assert( builder.KeyComparer == StringComparer.Ordinal || builder.KeyComparer == StringComparer.OrdinalIgnoreCase ); if (alias.TryGetWithoutAttributeSuffix(caseSensitive, out var aliasWithoutAttribute)) { builder.Add(aliasWithoutAttribute); return; } builder.Add(alias.GetWithSingleAttributeSuffix(caseSensitive)); }
protected void AddIfNotNullOrWhiteSpace(string name, string?value) { if (!RoslynString.IsNullOrWhiteSpace(value)) { Add(name, value); } }
protected void AddIfNotNullOrWhiteSpace(string name, string?value, bool addQuoteIfValueContainsWhitespace = true) { if (!RoslynString.IsNullOrWhiteSpace(value)) { Add(name, value, addQuoteIfValueContainsWhitespace); } }
private ProjectFileInfo CreateProjectFileInfo(MSB.Execution.ProjectInstance project) { var commandLineArgs = GetCommandLineArgs(project); var outputFilePath = project.ReadPropertyString(PropertyNames.TargetPath); if (!RoslynString.IsNullOrWhiteSpace(outputFilePath)) { outputFilePath = GetAbsolutePathRelativeToProject(outputFilePath); } var outputRefFilePath = project.ReadPropertyString(PropertyNames.TargetRefPath); if (!RoslynString.IsNullOrWhiteSpace(outputRefFilePath)) { outputRefFilePath = GetAbsolutePathRelativeToProject(outputRefFilePath); } // Right now VB doesn't have the concept of "default namespace". But we conjure one in workspace // by assigning the value of the project's root namespace to it. So various feature can choose to // use it for their own purpose. // In the future, we might consider officially exposing "default namespace" for VB project // (e.g. through a <defaultnamespace> msbuild property) var defaultNamespace = project.ReadPropertyString(PropertyNames.RootNamespace) ?? string.Empty; var targetFramework = project.ReadPropertyString(PropertyNames.TargetFramework); if (RoslynString.IsNullOrWhiteSpace(targetFramework)) { targetFramework = null; } var docs = project.GetDocuments() .Where(IsNotTemporaryGeneratedFile) .Select(MakeDocumentFileInfo) .ToImmutableArray(); var additionalDocs = project.GetAdditionalFiles() .Select(MakeNonSourceFileDocumentFileInfo) .ToImmutableArray(); var analyzerConfigDocs = project.GetEditorConfigFiles() .Select(MakeNonSourceFileDocumentFileInfo) .ToImmutableArray(); return(ProjectFileInfo.Create( Language, project.FullPath, outputFilePath, outputRefFilePath, defaultNamespace, targetFramework, commandLineArgs, docs, additionalDocs, analyzerConfigDocs, project.GetProjectReferences().ToImmutableArray(), Log)); }
protected void ReadErrorReport() { var errorReport = Project.ReadPropertyString(PropertyNames.ErrorReport); if (!RoslynString.IsNullOrWhiteSpace(errorReport)) { Add("errorreport", errorReport.ToLower()); } }
protected void ReadDelaySign() { var delaySign = Project.ReadPropertyString(PropertyNames.DelaySign); if (!RoslynString.IsNullOrWhiteSpace(delaySign)) { AddWithPlusOrMinus("delaysign", Conversions.ToBool(delaySign)); } }
private static string GetMSBuildFailedMessage(string projectFilePath, string message) => RoslynString.IsNullOrWhiteSpace(message) ? string.Format( WorkspaceMSBuildResources.Msbuild_failed_when_processing_the_file_0, projectFilePath ) : string.Format( WorkspaceMSBuildResources.Msbuild_failed_when_processing_the_file_0_with_message_1, projectFilePath, message );
protected void ReadPlatform() { var platform = Project.ReadPropertyString(PropertyNames.PlatformTarget); var prefer32bit = Project.ReadPropertyBool(PropertyNames.Prefer32Bit); if (prefer32bit && (RoslynString.IsNullOrWhiteSpace(platform) || string.Equals("anycpu", platform, StringComparison.OrdinalIgnoreCase))) { platform = "anycpu32bitpreferred"; } AddIfNotNullOrWhiteSpace("platform", platform); }
protected void ReadFeatures() { var features = Project.ReadPropertyString(PropertyNames.Features); if (!RoslynString.IsNullOrWhiteSpace(features)) { foreach (var feature in CompilerOptionParseUtilities.ParseFeatureFromMSBuild(features)) { Add("features", feature); } } }
protected void ReadSigning() { var signAssembly = Project.ReadPropertyBool(PropertyNames.SignAssembly); if (signAssembly) { var keyFile = Project.ReadPropertyString(PropertyNames.KeyOriginatorFile); if (!RoslynString.IsNullOrWhiteSpace(keyFile)) { Add("keyFile", keyFile); } var keyContainer = Project.ReadPropertyString(PropertyNames.KeyContainerName); if (!RoslynString.IsNullOrWhiteSpace(keyContainer)) { Add("keycontainer", keyContainer); } } }
private static void DiffRules( string oldRulesJsonPath, string newRulesJsonPath, string outputPath, string?latestRulesJsonPath = null) { RuleFileContent oldContent = ReadRuleFileContent(oldRulesJsonPath); RuleFileContent newContent = ReadRuleFileContent(newRulesJsonPath); // If we have the latest rules, we can backfill missing help link URLs. if (!RoslynString.IsNullOrWhiteSpace(latestRulesJsonPath)) { RuleFileContent latestContent = ReadRuleFileContent(latestRulesJsonPath); Dictionary <string, RuleInfo> latestRulesById = latestContent.Rules.ToDictionary(r => r.Id); foreach (RuleInfo rule in oldContent.Rules.Concat(newContent.Rules)) { if (RoslynString.IsNullOrWhiteSpace(rule.HelpLink) && latestRulesById.TryGetValue(rule.Id, out RuleInfo latestRule)) { rule.HelpLink = latestRule.HelpLink; } } } Dictionary <string, RuleInfo> oldRulesById = oldContent.Rules.ToDictionary(r => r.Id); Dictionary <string, RuleInfo> newRulesById = newContent.Rules.ToDictionary(r => r.Id); IEnumerable <RuleInfo> addedRules = newContent.Rules .Where(r => !oldRulesById.ContainsKey(r.Id)); IEnumerable <RuleInfo> removedRules = oldContent.Rules .Where(r => !newRulesById.ContainsKey(r.Id)); IEnumerable <RuleInfo> changedRules = newContent.Rules .Where(r => oldRulesById.TryGetValue(r.Id, out RuleInfo oldRule) && r.IsEnabledByDefault != oldRule.IsEnabledByDefault); StringBuilder sb = new StringBuilder(); GenerateAddRemovedRulesDiffMarkdown(sb, "### Added", addedRules); GenerateAddRemovedRulesDiffMarkdown(sb, "### Removed", removedRules); GenerateChangedRulesDiffMarkdown(sb, "### Changed", changedRules); File.WriteAllText(outputPath, sb.ToString()); }
private void ReadDoc() { var documentationFile = Project.ReadPropertyString(PropertyNames.DocFileItem); var generateDocumentation = Project.ReadPropertyBool(PropertyNames.GenerateDocumentation); var hasDocumentationFile = !RoslynString.IsNullOrWhiteSpace(documentationFile); if (hasDocumentationFile || generateDocumentation) { if (!RoslynString.IsNullOrWhiteSpace(documentationFile)) { Add("doc", documentationFile); } else { Add("doc"); } } }
private void ReadVbRuntime() { var vbRuntime = Project.ReadPropertyString(PropertyNames.VbRuntime); if (!RoslynString.IsNullOrWhiteSpace(vbRuntime)) { if (string.Equals("default", vbRuntime, StringComparison.OrdinalIgnoreCase)) { Add("vbruntime+"); } else if (string.Equals("embed", vbRuntime, StringComparison.OrdinalIgnoreCase)) { Add("vbruntime*"); } else if (string.Equals("none", vbRuntime, StringComparison.OrdinalIgnoreCase)) { Add("vbruntime-"); } else { Add("vbruntime", vbRuntime); } } }
public override string ToString() => RoslynString.IsNullOrWhiteSpace(TargetFramework) ? FilePath ?? string.Empty : $"{FilePath} ({TargetFramework})";
internal static void ParseResourceDescription( string resourceDescriptor, string?baseDirectory, bool skipLeadingSeparators, //VB does this out string?filePath, out string?fullPath, out string?fileName, out string resourceName, out string?accessibility) { filePath = null; fullPath = null; fileName = null; resourceName = ""; accessibility = null; // resource descriptor is: "<filePath>[,<string name>[,public|private]]" string[] parts = ParseSeparatedStrings(resourceDescriptor, s_resourceSeparators).ToArray(); int offset = 0; int length = parts.Length; if (skipLeadingSeparators) { for (; offset < length && string.IsNullOrEmpty(parts[offset]); offset++) { } length -= offset; } if (length >= 1) { filePath = RemoveQuotesAndSlashes(parts[offset + 0]); } if (length >= 2) { resourceName = RemoveQuotesAndSlashes(parts[offset + 1]); } if (length >= 3) { accessibility = RemoveQuotesAndSlashes(parts[offset + 2]); } if (RoslynString.IsNullOrWhiteSpace(filePath)) { return; } fileName = PathUtilities.GetFileName(filePath); fullPath = FileUtilities.ResolveRelativePath(filePath, baseDirectory); // The default resource name is the file name. // Also use the file name for the name when user specifies string like "filePath,,private" if (RoslynString.IsNullOrWhiteSpace(resourceName)) { resourceName = fileName; } }
private Task <ProjectInfo> CreateProjectInfoAsync( ProjectFileInfo projectFileInfo, ProjectId projectId, bool addDiscriminator, CancellationToken cancellationToken ) { var language = projectFileInfo.Language; var projectPath = projectFileInfo.FilePath; var projectName = Path.GetFileNameWithoutExtension(projectPath) ?? string.Empty; if ( addDiscriminator && !RoslynString.IsNullOrWhiteSpace(projectFileInfo.TargetFramework) ) { projectName += "(" + projectFileInfo.TargetFramework + ")"; } var version = projectPath is null ? VersionStamp.Default : VersionStamp.Create(FileUtilities.GetFileTimeStamp(projectPath)); if (projectFileInfo.IsEmpty) { var assemblyName = GetAssemblyNameFromProjectPath(projectPath); var parseOptions = GetLanguageService <ISyntaxTreeFactoryService>(language) ?.GetDefaultParseOptions(); var compilationOptions = GetLanguageService <ICompilationFactoryService>( language ) ?.GetDefaultCompilationOptions(); return(Task.FromResult( ProjectInfo.Create( projectId, version, projectName, assemblyName: assemblyName, language: language, filePath: projectPath, outputFilePath: string.Empty, outputRefFilePath: string.Empty, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), projectReferences: SpecializedCollections.EmptyEnumerable <ProjectReference>(), metadataReferences: SpecializedCollections.EmptyEnumerable <MetadataReference>(), analyzerReferences: SpecializedCollections.EmptyEnumerable <AnalyzerReference>(), additionalDocuments: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), isSubmission: false, hostObjectType: null ) )); } return(DoOperationAndReportProgressAsync( ProjectLoadOperation.Resolve, projectPath, projectFileInfo.TargetFramework, async() => { var projectDirectory = Path.GetDirectoryName(projectPath); // parse command line arguments var commandLineParser = GetLanguageService <ICommandLineParserService>( projectFileInfo.Language ); if (commandLineParser is null) { var message = string.Format( WorkspaceMSBuildResources.Unable_to_find_a_0_for_1, nameof(ICommandLineParserService), projectFileInfo.Language ); throw new Exception(message); } var commandLineArgs = commandLineParser.Parse( arguments: projectFileInfo.CommandLineArgs, baseDirectory: projectDirectory, isInteractive: false, sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory() ); var assemblyName = commandLineArgs.CompilationName; if (RoslynString.IsNullOrWhiteSpace(assemblyName)) { // if there isn't an assembly name, make one from the file path. // Note: This may not be necessary any longer if the command line args // always produce a valid compilation name. assemblyName = GetAssemblyNameFromProjectPath(projectPath); } // Ensure sure that doc-comments are 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 metadataService = GetWorkspaceService <IMetadataService>(); var compilationOptions = commandLineArgs.CompilationOptions .WithXmlReferenceResolver(new XmlFileResolver(projectDirectory)) .WithSourceReferenceResolver( new SourceFileResolver( ImmutableArray <string> .Empty, projectDirectory ) ) // TODO: https://github.com/dotnet/roslyn/issues/4967 .WithMetadataReferenceResolver( new WorkspaceMetadataFileReferenceResolver( metadataService, new RelativePathResolver( ImmutableArray <string> .Empty, projectDirectory ) ) ) .WithStrongNameProvider( new DesktopStrongNameProvider(commandLineArgs.KeyFileSearchPaths) ) .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); var documents = CreateDocumentInfos( projectFileInfo.Documents, projectId, commandLineArgs.Encoding ); var additionalDocuments = CreateDocumentInfos( projectFileInfo.AdditionalDocuments, projectId, commandLineArgs.Encoding ); var analyzerConfigDocuments = CreateDocumentInfos( projectFileInfo.AnalyzerConfigDocuments, projectId, commandLineArgs.Encoding ); CheckForDuplicateDocuments( documents.Concat(additionalDocuments).Concat(analyzerConfigDocuments), projectPath, projectId ); var analyzerReferences = ResolveAnalyzerReferences(commandLineArgs); var resolvedReferences = await ResolveReferencesAsync( projectId, projectFileInfo, commandLineArgs, cancellationToken ) .ConfigureAwait(false); return ProjectInfo .Create( projectId, version, projectName, assemblyName, language, projectPath, outputFilePath: projectFileInfo.OutputFilePath, outputRefFilePath: projectFileInfo.OutputRefFilePath, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: documents, projectReferences: resolvedReferences.ProjectReferences, metadataReferences: resolvedReferences.MetadataReferences, analyzerReferences: analyzerReferences, additionalDocuments: additionalDocuments, isSubmission: false, hostObjectType: null ) .WithDefaultNamespace(projectFileInfo.DefaultNamespace) .WithAnalyzerConfigDocuments(analyzerConfigDocuments) .WithCompilationOutputInfo( new CompilationOutputInfo(projectFileInfo.OutputFilePath) ); }