playtest-unity/playtest/Library/PackageCache/com.unity.ide.rider@3.0.21/Rider/Editor/ProjectGeneration/ProjectGeneration.cs

942 lines
35 KiB
C#
Raw Normal View History

2023-06-19 23:21:21 -04:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Text;
using Packages.Rider.Editor.Util;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEditorInternal;
using UnityEngine;
namespace Packages.Rider.Editor.ProjectGeneration
{
internal class ProjectGeneration : IGenerator
{
private enum ScriptingLanguage
{
None,
CSharp
}
public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003";
/// <summary>
/// Map source extensions to ScriptingLanguages
/// </summary>
private static readonly Dictionary<string, ScriptingLanguage> k_BuiltinSupportedExtensions =
new Dictionary<string, ScriptingLanguage>
{
{ "cs", ScriptingLanguage.CSharp },
{ "uxml", ScriptingLanguage.None },
{ "uss", ScriptingLanguage.None },
{ "shader", ScriptingLanguage.None },
{ "compute", ScriptingLanguage.None },
{ "cginc", ScriptingLanguage.None },
{ "hlsl", ScriptingLanguage.None },
{ "glslinc", ScriptingLanguage.None },
{ "template", ScriptingLanguage.None },
{ "raytrace", ScriptingLanguage.None },
{ "json", ScriptingLanguage.None},
{ "rsp", ScriptingLanguage.None},
{ "asmdef", ScriptingLanguage.None},
{ "asmref", ScriptingLanguage.None},
{ "xaml", ScriptingLanguage.None},
{ "tt", ScriptingLanguage.None},
{ "t4", ScriptingLanguage.None},
{ "ttinclude", ScriptingLanguage.None}
};
private string m_SolutionProjectEntryTemplate = string.Join(Environment.NewLine,
@"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""",
@"EndProject").Replace(" ", "\t");
private string m_SolutionProjectConfigurationTemplate = string.Join(Environment.NewLine,
@" {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU",
@" {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU").Replace(" ", "\t");
private string[] m_ProjectSupportedExtensions = new string[0];
public string ProjectDirectory { get; }
private readonly string m_ProjectName;
private readonly IAssemblyNameProvider m_AssemblyNameProvider;
private readonly IFileIO m_FileIOProvider;
private readonly IGUIDGenerator m_GUIDGenerator;
internal static bool isRiderProjectGeneration; // workaround to https://github.cds.internal.unity3d.com/unity/com.unity.ide.rider/issues/28
private const string k_ToolsVersion = "4.0";
private const string k_ProductVersion = "10.0.20506";
private const string k_BaseDirectory = ".";
private const string k_TargetLanguageVersion = "latest";
IAssemblyNameProvider IGenerator.AssemblyNameProvider => m_AssemblyNameProvider;
public ProjectGeneration()
: this(Directory.GetParent(Application.dataPath).FullName) { }
public ProjectGeneration(string tempDirectory)
: this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider()) { }
public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator)
{
ProjectDirectory = tempDirectory.NormalizePath();
m_ProjectName = Path.GetFileName(ProjectDirectory);
m_AssemblyNameProvider = assemblyNameProvider;
m_FileIOProvider = fileIoProvider;
m_GUIDGenerator = guidGenerator;
}
/// <summary>
/// Syncs the scripting solution if any affected files are relevant.
/// </summary>
/// <returns>
/// Whether the solution was synced.
/// </returns>
/// <param name='affectedFiles'>
/// A set of files whose status has changed
/// </param>
/// <param name="reimportedFiles">
/// A set of files that got reimported
/// </param>
/// <param name="checkProjectFiles">
/// Check if project files were changed externally
/// </param>
public bool SyncIfNeeded(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles, bool checkProjectFiles = false)
{
SetupSupportedExtensions();
PackageManagerTracker.SyncIfNeeded(checkProjectFiles);
if (HasFilesBeenModified(affectedFiles, reimportedFiles) || RiderScriptEditorData.instance.hasChanges
|| RiderScriptEditorData.instance.HasChangesInCompilationDefines()
|| (checkProjectFiles && LastWriteTracker.HasLastWriteTimeChanged()))
{
Sync();
return true;
}
return false;
}
private bool HasFilesBeenModified(IEnumerable<string> affectedFiles, IEnumerable<string> reimportedFiles)
{
return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset);
}
private static bool ShouldSyncOnReimportedAsset(string asset)
{
var extension = Path.GetExtension(asset);
return extension == ".asmdef" || extension == ".asmref" || Path.GetFileName(asset) == "csc.rsp";
}
public void Sync()
{
SetupSupportedExtensions();
var types = GetAssetPostprocessorTypes();
isRiderProjectGeneration = true;
var externalCodeAlreadyGeneratedProjects = OnPreGeneratingCSProjectFiles(types);
isRiderProjectGeneration = false;
if (!externalCodeAlreadyGeneratedProjects)
{
GenerateAndWriteSolutionAndProjects(types);
}
OnGeneratedCSProjectFiles(types);
m_AssemblyNameProvider.ResetPackageInfoCache();
m_AssemblyNameProvider.ResetAssembliesCache();
RiderScriptEditorData.instance.hasChanges = false;
RiderScriptEditorData.instance.InvalidateSavedCompilationDefines();
}
public bool HasSolutionBeenGenerated()
{
return m_FileIOProvider.Exists(SolutionFile());
}
private void SetupSupportedExtensions()
{
m_ProjectSupportedExtensions = m_AssemblyNameProvider.ProjectSupportedExtensions;
}
private bool ShouldFileBePartOfSolution(string file)
{
// Exclude files coming from packages except if they are internalized.
if (m_AssemblyNameProvider.IsInternalizedPackagePath(file))
{
return false;
}
return HasValidExtension(file);
}
public bool HasValidExtension(string file)
{
var extension = Path.GetExtension(file);
// Dll's are not scripts but still need to be included..
if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase))
return true;
return IsSupportedExtension(extension);
}
private bool IsSupportedExtension(string extension)
{
extension = extension.TrimStart('.');
return k_BuiltinSupportedExtensions.ContainsKey(extension) || m_ProjectSupportedExtensions.Contains(extension);
}
public void GenerateAndWriteSolutionAndProjects(Type[] types)
{
// Only synchronize islands that have associated source files and ones that we actually want in the project.
// This also filters out DLLs coming from .asmdef files in packages.
var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution).ToArray();
var allAssetProjectParts = GenerateAllAssetProjectParts();
var projectParts = new List<ProjectPart>();
var visitedAssemblyNames = new HashSet<string>();
foreach (var assembly in assemblies)
{
if (visitedAssemblyNames.Contains(assembly.name))
projectParts.Add(new ProjectPart(assembly.name, assembly, string.Empty)); // do not add asset project parts to both editor and player projects
else
{
allAssetProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject);
projectParts.Add(new ProjectPart(assembly.name, assembly, additionalAssetsForProject));
visitedAssemblyNames.Add(assembly.name);
}
}
var executingAssemblyName = typeof(ProjectGeneration).Assembly.GetName().Name;
var riderAssembly = m_AssemblyNameProvider.GetAssemblies(_ => true).FirstOrDefault(a=>a.name == executingAssemblyName);
var projectPartsWithoutAssembly = allAssetProjectParts.Where(a => !visitedAssemblyNames.Contains(a.Key));
projectParts.AddRange(projectPartsWithoutAssembly.Select(allAssetProjectPart =>
AddProjectPart(allAssetProjectPart.Key, riderAssembly, allAssetProjectPart.Value)));
SyncSolution(projectParts.ToArray(), types);
foreach (var projectPart in projectParts)
{
SyncProject(projectPart, types);
}
}
private static ProjectPart AddProjectPart(string assemblyName, Assembly riderAssembly, string assetProjectPart)
{
Assembly assembly = null;
if (riderAssembly != null)
// We want to add those references, so that Rider would detect Unity path and version and provide rich features for shader files
assembly = new Assembly(assemblyName, riderAssembly.outputPath, Array.Empty<string>(),
new []{"UNITY_EDITOR"},
Array.Empty<Assembly>(),
riderAssembly.compiledAssemblyReferences.Where(a =>
a.EndsWith("UnityEditor.dll", StringComparison.Ordinal) || a.EndsWith("UnityEngine.dll", StringComparison.Ordinal) ||
a.EndsWith("UnityEngine.CoreModule.dll", StringComparison.Ordinal)).ToArray(), riderAssembly.flags);
return new ProjectPart(assemblyName, assembly, assetProjectPart);
}
private Dictionary<string, string> GenerateAllAssetProjectParts()
{
var stringBuilders = new Dictionary<string, StringBuilder>();
foreach (var asset in m_AssemblyNameProvider.GetAllAssetPaths())
{
// Exclude files coming from packages except if they are internalized.
if (m_AssemblyNameProvider.IsInternalizedPackagePath(asset))
{
continue;
}
var fallbackAssemblyName = "Assembly-CSharp";
var extension = Path.GetExtension(asset);
if (AssetDatabase.IsValidFolder(asset))
{
var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath($"{asset}/asset.cs");
if (string.IsNullOrEmpty(assemblyName))
{
assemblyName = fallbackAssemblyName;
}
assemblyName = FileSystemUtil.FileNameWithoutExtension(assemblyName);
if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
{
projectBuilder = new StringBuilder();
stringBuilders[assemblyName] = projectBuilder;
}
projectBuilder.Append(" <Folder Include=\"").Append(m_FileIOProvider.EscapedRelativePathFor(asset, ProjectDirectory)).Append("\" />")
.Append(Environment.NewLine);
}
else if (IsSupportedExtension(extension) && !extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
{
// Find assembly the asset belongs to by adding script extension and using compilation pipeline.
var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset + ".cs");
if (string.IsNullOrEmpty(assemblyName))
{
assemblyName = fallbackAssemblyName;
}
assemblyName = FileSystemUtil.FileNameWithoutExtension(assemblyName);
if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder))
{
projectBuilder = new StringBuilder();
stringBuilders[assemblyName] = projectBuilder;
}
projectBuilder.Append(" <None Include=\"").Append(m_FileIOProvider.EscapedRelativePathFor(asset, ProjectDirectory)).Append("\" />")
.Append(Environment.NewLine);
}
}
var result = new Dictionary<string, string>();
foreach (var entry in stringBuilders)
result[entry.Key] = entry.Value.ToString();
return result;
}
private void SyncProject(
ProjectPart island,
Type[] types)
{
SyncProjectFileIfNotChanged(
ProjectFile(island),
ProjectText(island),
types);
}
private void SyncProjectFileIfNotChanged(string path, string newContents, Type[] types)
{
if (Path.GetExtension(path) == ".csproj")
{
newContents = OnGeneratedCSProject(path, newContents, types);
}
SyncFileIfNotChanged(path, newContents);
}
private void SyncSolutionFileIfNotChanged(string path, string newContents, Type[] types)
{
newContents = OnGeneratedSlnSolution(path, newContents, types);
SyncFileIfNotChanged(path, newContents);
}
private static void OnGeneratedCSProjectFiles(Type[] types)
{
foreach (var type in types)
{
var method = type.GetMethod("OnGeneratedCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
Debug.LogWarning("OnGeneratedCSProjectFiles is not supported.");
// RIDER-51958
//method.Invoke(null, args);
}
}
public static Type[] GetAssetPostprocessorTypes()
{
return TypeCache.GetTypesDerivedFrom<AssetPostprocessor>().ToArray(); // doesn't find types from EditorPlugin, which is fine
}
private static bool OnPreGeneratingCSProjectFiles(Type[] types)
{
var result = false;
foreach (var type in types)
{
var args = new object[0];
var method = type.GetMethod("OnPreGeneratingCSProjectFiles",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(bool))
{
result |= (bool)returnValue;
}
}
return result;
}
private static string OnGeneratedCSProject(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] { path, content };
var method = type.GetMethod("OnGeneratedCSProject",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string)returnValue;
}
}
return content;
}
private static string OnGeneratedSlnSolution(string path, string content, Type[] types)
{
foreach (var type in types)
{
var args = new[] { path, content };
var method = type.GetMethod("OnGeneratedSlnSolution",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Static);
if (method == null)
{
continue;
}
var returnValue = method.Invoke(null, args);
if (method.ReturnType == typeof(string))
{
content = (string)returnValue;
}
}
return content;
}
private void SyncFileIfNotChanged(string path, string newContents)
{
try
{
if (m_FileIOProvider.Exists(path) && newContents == m_FileIOProvider.ReadAllText(path))
{
return;
}
}
catch (Exception exception)
{
Debug.LogException(exception);
}
m_FileIOProvider.WriteAllText(path, newContents);
}
private string ProjectText(ProjectPart assembly)
{
var responseFilesData = assembly.ParseResponseFileData(m_AssemblyNameProvider, ProjectDirectory).ToList();
var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
foreach (var file in assembly.SourceFiles)
{
var fullFile = m_FileIOProvider.EscapedRelativePathFor(file, ProjectDirectory);
projectBuilder.Append(" <Compile Include=\"").Append(fullFile).Append("\" />").Append(Environment.NewLine);
}
projectBuilder.Append(assembly.AssetsProjectPart);
var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
var internalAssemblyReferences = assembly.AssemblyReferences
.Where(reference => !reference.sourceFiles.Any(ShouldFileBePartOfSolution)).Select(i => i.outputPath);
var allReferences =
assembly.CompiledAssemblyReferences
.Union(responseRefs)
.Union(internalAssemblyReferences).ToArray();
foreach (var reference in allReferences)
{
var fullReference = Path.IsPathRooted(reference) ? reference : Path.GetFullPath(reference);
AppendReference(fullReference, projectBuilder);
}
if (0 < assembly.AssemblyReferences.Length)
{
projectBuilder.Append(" </ItemGroup>").Append(Environment.NewLine);
projectBuilder.Append(" <ItemGroup>").Append(Environment.NewLine);
foreach (var reference in assembly.AssemblyReferences.Where(i => i.sourceFiles.Any(ShouldFileBePartOfSolution)))
{
var name = m_AssemblyNameProvider.GetProjectName(reference.name, reference.defines);
projectBuilder.Append(" <ProjectReference Include=\"").Append(name).Append(GetProjectExtension()).Append("\">").Append(Environment.NewLine);
projectBuilder.Append(" <Project>{").Append(ProjectGuid(name)).Append("}</Project>").Append(Environment.NewLine);
projectBuilder.Append(" <Name>").Append(name).Append("</Name>").Append(Environment.NewLine);
projectBuilder.Append(" </ProjectReference>").Append(Environment.NewLine);
}
}
projectBuilder.Append(ProjectFooter());
return projectBuilder.ToString();
}
private static void AppendReference(string fullReference, StringBuilder projectBuilder)
{
var escapedFullPath = SecurityElement.Escape(fullReference);
escapedFullPath = escapedFullPath.NormalizePath();
projectBuilder.Append(" <Reference Include=\"").Append(FileSystemUtil.FileNameWithoutExtension(escapedFullPath))
.Append("\">").Append(Environment.NewLine);
projectBuilder.Append(" <HintPath>").Append(escapedFullPath).Append("</HintPath>").Append(Environment.NewLine);
projectBuilder.Append(" </Reference>").Append(Environment.NewLine);
}
private string ProjectFile(ProjectPart projectPart)
{
return Path.Combine(ProjectDirectory, $"{m_AssemblyNameProvider.GetProjectName(projectPart.Name, projectPart.Defines)}.csproj");
}
public string SolutionFile()
{
return Path.Combine(ProjectDirectory, $"{m_ProjectName}.sln");
}
private string ProjectHeader(
ProjectPart assembly,
List<ResponseFileData> responseFilesData
)
{
var otherResponseFilesData = GetOtherArgumentsFromResponseFilesData(responseFilesData);
var arguments = new object[]
{
k_ToolsVersion,
k_ProductVersion,
ProjectGuid(m_AssemblyNameProvider.GetProjectName(assembly.Name, assembly.Defines)),
InternalEditorUtility.GetEngineAssemblyPath(),
InternalEditorUtility.GetEditorAssemblyPath(),
string.Join(";", assembly.Defines.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
assembly.Name,
assembly.OutputPath,
assembly.RootNamespace,
assembly.CompilerOptions.ApiCompatibilityLevel,
GenerateLangVersion(otherResponseFilesData["langversion"], assembly),
k_BaseDirectory,
assembly.CompilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
GenerateNoWarn(otherResponseFilesData["nowarn"].Distinct().ToList()),
GenerateAnalyserItemGroup(RetrieveRoslynAnalyzers(assembly, otherResponseFilesData)),
GenerateAnalyserAdditionalFiles(RetrieveAdditionalFiles(assembly, otherResponseFilesData)),
GenerateRoslynAnalyzerRulesetPath(assembly, otherResponseFilesData),
GenerateWarningLevel(otherResponseFilesData["warn"].Concat(otherResponseFilesData["w"]).Distinct()),
GenerateWarningAsError(otherResponseFilesData["warnaserror"], otherResponseFilesData["warnaserror-"], otherResponseFilesData["warnaserror+"]),
GenerateDocumentationFile(otherResponseFilesData["doc"].ToArray()),
GenerateNullable(otherResponseFilesData["nullable"]),
GenerateGlobalAnalyzerConfigFiles(assembly)
};
try
{
return string.Format(GetProjectHeaderTemplate(), arguments);
}
catch (Exception)
{
throw new NotSupportedException(
"Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " +
arguments.Length);
}
}
private static string GenerateGlobalAnalyzerConfigFiles(ProjectPart assembly)
{
var configFile =
#if UNITY_2021_3 || UNITY_2022_2_OR_NEWER
assembly.CompilerOptions.AnalyzerConfigPath; // https://docs.unity3d.com/2021.3/Documentation/ScriptReference/Compilation.ScriptCompilerOptions.AnalyzerConfigPath.html
#else
string.Empty;
#endif
if (string.IsNullOrEmpty(configFile))
return string.Empty;
var builder = new StringBuilder();
builder.AppendLine(" <ItemGroup>");
builder.AppendLine($" <GlobalAnalyzerConfigFiles Include=\"{configFile}\" />");
builder.AppendLine(" </ItemGroup>");
return builder.ToString();
}
private static string[] RetrieveAdditionalFiles(ProjectPart assembly, ILookup<string, string> otherResponseFilesData)
{
return otherResponseFilesData["additionalfile"]
.SelectMany(x=>x.Split(';'))
#if UNITY_2021_3 || UNITY_2022_2_OR_NEWER // https://docs.unity3d.com/2021.3/Documentation/ScriptReference/Compilation.ScriptCompilerOptions.RoslynAdditionalFilePaths.html
.Concat(assembly.CompilerOptions.RoslynAdditionalFilePaths)
#endif
.Distinct().ToArray();
}
string[] RetrieveRoslynAnalyzers(ProjectPart assembly, ILookup<string, string> otherResponseFilesData)
{
#if UNITY_2020_2_OR_NEWER
return otherResponseFilesData["analyzer"].Concat(otherResponseFilesData["a"])
.SelectMany(x=>x.Split(';'))
#if !ROSLYN_ANALYZER_FIX
.Concat(m_AssemblyNameProvider.GetRoslynAnalyzerPaths())
#else
.Concat(assembly.CompilerOptions.RoslynAnalyzerDllPaths)
#endif
.Select(MakeAbsolutePath)
.Distinct()
.ToArray();
#else
return otherResponseFilesData["analyzer"].Concat(otherResponseFilesData["a"])
.SelectMany(x=>x.Split(';'))
.Distinct()
.Select(MakeAbsolutePath)
.ToArray();
#endif
}
private static string MakeAbsolutePath(string path)
{
return Path.IsPathRooted(path) ? path : Path.GetFullPath(path);
}
private string GenerateRoslynAnalyzerRulesetPath(ProjectPart assembly, ILookup<string, string> otherResponseFilesData)
{
#if UNITY_2020_2_OR_NEWER
return GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Append(assembly.CompilerOptions.RoslynAnalyzerRulesetPath).Where(a=>!string.IsNullOrEmpty(a)).Distinct().Select(x => MakeAbsolutePath(x).NormalizePath()).ToArray());
#else
return GenerateAnalyserRuleSet(otherResponseFilesData["ruleset"].Distinct().Select(x => MakeAbsolutePath(x).NormalizePath()).ToArray());
#endif
}
private string GenerateNullable(IEnumerable<string> enumerable)
{
var val = enumerable.FirstOrDefault();
if (string.IsNullOrWhiteSpace(val))
return string.Empty;
return $"{Environment.NewLine} <Nullable>{val}</Nullable>";
}
private static string GenerateDocumentationFile(string[] paths)
{
if (!paths.Any())
return String.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <DocumentationFile>{a}</DocumentationFile>"))}";
}
private static string GenerateWarningAsError(IEnumerable<string> args, IEnumerable<string> argsMinus, IEnumerable<string> argsPlus)
{
var returnValue = String.Empty;
var allWarningsAsErrors = false;
var warningIds = new List<string>();
foreach (var s in args)
{
if (s == "+" || s == string.Empty) allWarningsAsErrors = true;
else if (s == "-") allWarningsAsErrors = false;
else
{
warningIds.Add(s);
}
}
warningIds.AddRange(argsPlus);
returnValue += $@" <TreatWarningsAsErrors>{allWarningsAsErrors}</TreatWarningsAsErrors>";
if (warningIds.Any())
{
returnValue += $"{Environment.NewLine} <WarningsAsErrors>{string.Join(";", warningIds)}</WarningsAsErrors>";
}
if (argsMinus.Any())
returnValue += $"{Environment.NewLine} <WarningsNotAsErrors>{string.Join(";", argsMinus)}</WarningsNotAsErrors>";
return $"{Environment.NewLine}{returnValue}";
}
private static string GenerateWarningLevel(IEnumerable<string> warningLevel)
{
var level = warningLevel.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(level))
return level;
return 4.ToString();
}
private static string GetSolutionText()
{
return string.Join(Environment.NewLine,
@"",
@"Microsoft Visual Studio Solution File, Format Version {0}",
@"# Visual Studio {1}",
@"{2}",
@"Global",
@" GlobalSection(SolutionConfigurationPlatforms) = preSolution",
@" Debug|Any CPU = Debug|Any CPU",
@" EndGlobalSection",
@" GlobalSection(ProjectConfigurationPlatforms) = postSolution",
@"{3}",
@" EndGlobalSection",
@" GlobalSection(SolutionProperties) = preSolution",
@" HideSolutionNode = FALSE",
@" EndGlobalSection",
@"EndGlobal",
@"").Replace(" ", "\t");
}
private static string GetProjectFooterTemplate()
{
return string.Join(Environment.NewLine,
@" </ItemGroup>",
@" <Import Project=""$(MSBuildToolsPath)\Microsoft.CSharp.targets"" />",
@" <!-- To modify your build process, add your task inside one of the targets below and uncomment it.",
@" Other similar extension points exist, see Microsoft.Common.targets.",
@" <Target Name=""BeforeBuild"">",
@" </Target>",
@" <Target Name=""AfterBuild"">",
@" </Target>",
@" -->",
@"</Project>",
@"");
}
private static string GetProjectHeaderTemplate()
{
var header = new[]
{
@"<?xml version=""1.0"" encoding=""utf-8""?>",
@"<Project ToolsVersion=""{0}"" DefaultTargets=""Build"" xmlns=""{6}"">",
@" <PropertyGroup>",
@" <LangVersion>{11}</LangVersion>",
@" <_TargetFrameworkDirectories>non_empty_path_generated_by_unity.rider.package</_TargetFrameworkDirectories>",
@" <_FullFrameworkReferenceAssemblyPaths>non_empty_path_generated_by_unity.rider.package</_FullFrameworkReferenceAssemblyPaths>",
@" <DisableHandlePackageFileConflicts>true</DisableHandlePackageFileConflicts>{17}",
@" </PropertyGroup>",
@" <PropertyGroup>",
@" <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>",
@" <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>",
@" <ProductVersion>{1}</ProductVersion>",
@" <SchemaVersion>2.0</SchemaVersion>",
@" <RootNamespace>{9}</RootNamespace>",
@" <ProjectGuid>{{{2}}}</ProjectGuid>",
@" <ProjectTypeGuids>{{E097FAD1-6243-4DAD-9C02-E9B9EFC3FFC1}};{{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}}</ProjectTypeGuids>",
@" <OutputType>Library</OutputType>",
@" <AppDesignerFolder>Properties</AppDesignerFolder>",
@" <AssemblyName>{7}</AssemblyName>",
@" <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>",
@" <FileAlignment>512</FileAlignment>",
@" <BaseDirectory>{12}</BaseDirectory>",
@" </PropertyGroup>",
@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">",
@" <DebugSymbols>true</DebugSymbols>",
@" <DebugType>full</DebugType>",
@" <Optimize>false</Optimize>",
@" <OutputPath>{8}</OutputPath>",
@" <DefineConstants>{5}</DefineConstants>",
@" <ErrorReport>prompt</ErrorReport>",
@" <WarningLevel>{18}</WarningLevel>",
@" <NoWarn>{14}</NoWarn>",
@" <AllowUnsafeBlocks>{13}</AllowUnsafeBlocks>{19}{20}{21}",
@" </PropertyGroup>"
};
var forceExplicitReferences = new[]
{
@" <PropertyGroup>",
@" <NoConfig>true</NoConfig>",
@" <NoStdLib>true</NoStdLib>",
@" <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>",
@" <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>",
@" <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>",
@" </PropertyGroup>"
};
var footer = new[]
{
@"{15}{16}{22} <ItemGroup>",
@""
};
var pieces = header.Concat(forceExplicitReferences).Concat(footer).ToArray();
return string.Join(Environment.NewLine, pieces);
}
private void SyncSolution(ProjectPart[] islands, Type[] types)
{
SyncSolutionFileIfNotChanged(SolutionFile(), SolutionText(islands), types);
}
private string SolutionText(ProjectPart[] islands)
{
var fileversion = "11.00";
var vsversion = "2010";
var projectEntries = GetProjectEntries(islands);
var projectConfigurations = string.Join(Environment.NewLine,
islands.Select(i => GetProjectActiveConfigurations(ProjectGuid(m_AssemblyNameProvider.GetProjectName(i.Name, i.Defines)))).ToArray());
return string.Format(GetSolutionText(), fileversion, vsversion, projectEntries, projectConfigurations);
}
private static string GenerateAnalyserItemGroup(string[] paths)
{
// <ItemGroup>
// <Analyzer Include="..\packages\Comments_analyser.1.0.6626.21356\analyzers\dotnet\cs\Comments_analyser.dll" />
// <Analyzer Include="..\packages\UnityEngineAnalyzer.1.0.0.0\analyzers\dotnet\cs\UnityEngineAnalyzer.dll" />
// </ItemGroup>
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <Analyzer Include=\"{path.NormalizePath()}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
private static ILookup<string, string> GetOtherArgumentsFromResponseFilesData(List<ResponseFileData> responseFilesData)
{
var paths = responseFilesData.SelectMany(x =>
{
return x.OtherArguments
.Where(a => a.StartsWith("/", StringComparison.Ordinal) || a.StartsWith("-", StringComparison.Ordinal))
.Select(b =>
{
var index = b.IndexOf(":", StringComparison.Ordinal);
if (index > 0 && b.Length > index)
{
var key = b.Substring(1, index - 1);
return new KeyValuePair<string, string>(key, b.Substring(index + 1));
}
const string warnaserror = "warnaserror";
if (b.Substring(1).StartsWith(warnaserror, StringComparison.Ordinal))
{
return new KeyValuePair<string, string>(warnaserror, b.Substring(warnaserror.Length + 1));
}
const string nullable = "nullable";
if (b.Substring(1).StartsWith(nullable, StringComparison.Ordinal))
{
var res = b.Substring(nullable.Length + 1);
if (string.IsNullOrWhiteSpace(res) || res.Equals("+"))
res = "enable";
else if (res.Equals("-"))
res = "disable";
return new KeyValuePair<string, string>(nullable, res);
}
return default;
});
})
.Distinct()
.ToLookup(o => o.Key, pair => pair.Value);
return paths;
}
private string GenerateLangVersion(IEnumerable<string> langVersionList, ProjectPart assembly)
{
var langVersion = langVersionList.FirstOrDefault();
if (!string.IsNullOrWhiteSpace(langVersion))
return langVersion;
#if UNITY_2020_2_OR_NEWER
return assembly.CompilerOptions.LanguageVersion;
#else
return k_TargetLanguageVersion;
#endif
}
private static string GenerateAnalyserRuleSet(string[] paths)
{
//<CodeAnalysisRuleSet>..\path\to\myrules.ruleset</CodeAnalysisRuleSet>
if (!paths.Any())
return string.Empty;
return $"{Environment.NewLine}{string.Join(Environment.NewLine, paths.Select(a => $" <CodeAnalysisRuleSet>{a}</CodeAnalysisRuleSet>"))}";
}
private static string GenerateAnalyserAdditionalFiles(string[] paths)
{
if (!paths.Any())
return string.Empty;
var analyserBuilder = new StringBuilder();
analyserBuilder.AppendLine(" <ItemGroup>");
foreach (var path in paths)
{
analyserBuilder.AppendLine($" <AdditionalFiles Include=\"{path}\" />");
}
analyserBuilder.AppendLine(" </ItemGroup>");
return analyserBuilder.ToString();
}
public static string GenerateNoWarn(List<string> codes)
{
#if UNITY_2020_1 // RIDER-77206 Unity 2020.1.3 'PlayerSettings' does not contain a definition for 'suppressCommonWarnings'
var type = typeof(PlayerSettings);
var propertyInfo = type.GetProperty("suppressCommonWarnings");
if (propertyInfo != null && propertyInfo.GetValue(null) is bool && (bool)propertyInfo.GetValue(null))
{
codes.AddRange(new[] {"0169", "0649"});
}
#elif UNITY_2020_2_OR_NEWER
if (PlayerSettings.suppressCommonWarnings)
codes.AddRange(new[] {"0169", "0649"});
#endif
if (!codes.Any())
return string.Empty;
return string.Join(",", codes.Distinct());
}
private string GetProjectEntries(ProjectPart[] islands)
{
var projectEntries = islands.Select(i => string.Format(
m_SolutionProjectEntryTemplate,
SolutionGuidGenerator.GuidForSolution(),
i.Name,
Path.GetFileName(ProjectFile(i)),
ProjectGuid(m_AssemblyNameProvider.GetProjectName(i.Name, i.Defines))
));
return string.Join(Environment.NewLine, projectEntries.ToArray());
}
/// <summary>
/// Generate the active configuration string for a given project guid
/// </summary>
private string GetProjectActiveConfigurations(string projectGuid)
{
return string.Format(
m_SolutionProjectConfigurationTemplate,
projectGuid);
}
private static string ProjectFooter()
{
return GetProjectFooterTemplate();
}
private static string GetProjectExtension()
{
return ".csproj";
}
private string ProjectGuid(string name)
{
return m_GUIDGenerator.ProjectGuid(m_ProjectName + name);
}
}
}