using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Security; using System.Security.Cryptography; using System.Text; using System.Text.RegularExpressions; using UnityEditor; using UnityEditor.Compilation; using UnityEditor.PackageManager; using UnityEngine; using UnityEngine.Profiling; namespace VSCodeEditor { public interface IGenerator { bool SyncIfNeeded(List affectedFiles, string[] reimportedFiles); void Sync(); string SolutionFile(); string ProjectDirectory { get; } void GenerateAll(bool generateAll); bool SolutionExists(); } public class ProjectGeneration : IGenerator { enum ScriptingLanguage { None, CSharp } public static readonly string MSBuildNamespaceUri = "http://schemas.microsoft.com/developer/msbuild/2003"; const string k_WindowsNewline = "\r\n"; const string k_SettingsJson = @"{ ""files.exclude"": { ""**/.DS_Store"":true, ""**/.git"":true, ""**/.gitignore"":true, ""**/.gitmodules"":true, ""**/*.booproj"":true, ""**/*.pidb"":true, ""**/*.suo"":true, ""**/*.user"":true, ""**/*.userprefs"":true, ""**/*.unityproj"":true, ""**/*.dll"":true, ""**/*.exe"":true, ""**/*.pdf"":true, ""**/*.mid"":true, ""**/*.midi"":true, ""**/*.wav"":true, ""**/*.gif"":true, ""**/*.ico"":true, ""**/*.jpg"":true, ""**/*.jpeg"":true, ""**/*.png"":true, ""**/*.psd"":true, ""**/*.tga"":true, ""**/*.tif"":true, ""**/*.tiff"":true, ""**/*.3ds"":true, ""**/*.3DS"":true, ""**/*.fbx"":true, ""**/*.FBX"":true, ""**/*.lxo"":true, ""**/*.LXO"":true, ""**/*.ma"":true, ""**/*.MA"":true, ""**/*.obj"":true, ""**/*.OBJ"":true, ""**/*.asset"":true, ""**/*.cubemap"":true, ""**/*.flare"":true, ""**/*.mat"":true, ""**/*.meta"":true, ""**/*.prefab"":true, ""**/*.unity"":true, ""build/"":true, ""Build/"":true, ""Library/"":true, ""library/"":true, ""obj/"":true, ""Obj/"":true, ""ProjectSettings/"":true, ""temp/"":true, ""Temp/"":true } }"; /// /// Map source extensions to ScriptingLanguages /// static readonly Dictionary k_BuiltinSupportedExtensions = new Dictionary { { "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 } }; string m_SolutionProjectEntryTemplate = string.Join("\r\n", @"Project(""{{{0}}}"") = ""{1}"", ""{2}"", ""{{{3}}}""", @"EndProject").Replace(" ", "\t"); string m_SolutionProjectConfigurationTemplate = string.Join("\r\n", @" {{{0}}}.Debug|Any CPU.ActiveCfg = Debug|Any CPU", @" {{{0}}}.Debug|Any CPU.Build.0 = Debug|Any CPU", @" {{{0}}}.Release|Any CPU.ActiveCfg = Release|Any CPU", @" {{{0}}}.Release|Any CPU.Build.0 = Release|Any CPU").Replace(" ", "\t"); static readonly string[] k_ReimportSyncExtensions = { ".dll", ".asmdef" }; string[] m_ProjectSupportedExtensions = new string[0]; public string ProjectDirectory { get; } bool m_ShouldGenerateAll; public void GenerateAll(bool generateAll) { m_ShouldGenerateAll = generateAll; } readonly string m_ProjectName; readonly IAssemblyNameProvider m_AssemblyNameProvider; readonly IFileIO m_FileIOProvider; readonly IGUIDGenerator m_GUIDProvider; const string k_ToolsVersion = "4.0"; const string k_ProductVersion = "10.0.20506"; const string k_BaseDirectory = "."; const string k_TargetFrameworkVersion = "v4.7.1"; const string k_TargetLanguageVersion = "latest"; public ProjectGeneration(string tempDirectory) : this(tempDirectory, new AssemblyNameProvider(), new FileIOProvider(), new GUIDProvider()) { } public ProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIO, IGUIDGenerator guidGenerator) { ProjectDirectory = tempDirectory.Replace('\\', '/'); m_ProjectName = Path.GetFileName(ProjectDirectory); m_AssemblyNameProvider = assemblyNameProvider; m_FileIOProvider = fileIO; m_GUIDProvider = guidGenerator; } /// /// Syncs the scripting solution if any affected files are relevant. /// /// /// Whether the solution was synced. /// /// /// A set of files whose status has changed /// /// /// A set of files that got reimported /// public bool SyncIfNeeded(List affectedFiles, string[] reimportedFiles) { Profiler.BeginSample("SolutionSynchronizerSync"); SetupProjectSupportedExtensions(); // Don't sync if we haven't synced before if (SolutionExists() && HasFilesBeenModified(affectedFiles, reimportedFiles)) { var assemblies = m_AssemblyNameProvider.GetAssemblies(ShouldFileBePartOfSolution); var allProjectAssemblies = RelevantAssembliesForMode(assemblies).ToList(); var allAssetProjectParts = GenerateAllAssetProjectParts(); var affectedNames = affectedFiles.Select(asset => m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset)?.Split(new [] {".dll"}, StringSplitOptions.RemoveEmptyEntries)[0]); var reimportedNames = reimportedFiles.Select(asset => m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset)?.Split(new [] {".dll"}, StringSplitOptions.RemoveEmptyEntries)[0]); var affectedAndReimported = new HashSet(affectedNames.Concat(reimportedNames)); var assemblyNames = new HashSet(allProjectAssemblies.Select(assembly => Path.GetFileName(assembly.outputPath))); foreach (var assembly in allProjectAssemblies) { if (!affectedAndReimported.Contains(assembly.name)) continue; SyncProject(assembly, allAssetProjectParts, ParseResponseFileData(assembly), assemblyNames); } Profiler.EndSample(); return true; } Profiler.EndSample(); return false; } bool HasFilesBeenModified(List affectedFiles, string[] reimportedFiles) { return affectedFiles.Any(ShouldFileBePartOfSolution) || reimportedFiles.Any(ShouldSyncOnReimportedAsset); } static bool ShouldSyncOnReimportedAsset(string asset) { return k_ReimportSyncExtensions.Contains(new FileInfo(asset).Extension); } public void Sync() { SetupProjectSupportedExtensions(); GenerateAndWriteSolutionAndProjects(); } public bool SolutionExists() { return m_FileIOProvider.Exists(SolutionFile()); } void SetupProjectSupportedExtensions() { m_ProjectSupportedExtensions = EditorSettings.projectGenerationUserExtensions; } bool ShouldFileBePartOfSolution(string file) { string extension = Path.GetExtension(file); // Exclude files coming from packages except if they are internalized. if (!m_ShouldGenerateAll && IsInternalizedPackagePath(file)) { return false; } // Dll's are not scripts but still need to be included.. if (extension == ".dll") return true; if (file.ToLower().EndsWith(".asmdef")) return true; return IsSupportedExtension(extension); } bool IsSupportedExtension(string extension) { extension = extension.TrimStart('.'); if (k_BuiltinSupportedExtensions.ContainsKey(extension)) return true; if (m_ProjectSupportedExtensions.Contains(extension)) return true; return false; } static ScriptingLanguage ScriptingLanguageFor(Assembly assembly) { return ScriptingLanguageFor(GetExtensionOfSourceFiles(assembly.sourceFiles)); } static string GetExtensionOfSourceFiles(string[] files) { return files.Length > 0 ? GetExtensionOfSourceFile(files[0]) : "NA"; } static string GetExtensionOfSourceFile(string file) { var ext = Path.GetExtension(file).ToLower(); ext = ext.Substring(1); //strip dot return ext; } static ScriptingLanguage ScriptingLanguageFor(string extension) { return k_BuiltinSupportedExtensions.TryGetValue(extension.TrimStart('.'), out var result) ? result : ScriptingLanguage.None; } public void GenerateAndWriteSolutionAndProjects() { // Only synchronize assemblies 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); var allAssetProjectParts = GenerateAllAssetProjectParts(); SyncSolution(assemblies); var allProjectAssemblies = RelevantAssembliesForMode(assemblies).ToList(); var assemblyNames = new HashSet(allProjectAssemblies.Select(assembly => Path.GetFileName(assembly.outputPath))); foreach (Assembly assembly in allProjectAssemblies) { var responseFileData = ParseResponseFileData(assembly); SyncProject(assembly, allAssetProjectParts, responseFileData, assemblyNames); } WriteVSCodeSettingsFiles(); } IEnumerable ParseResponseFileData(Assembly assembly) { var systemReferenceDirectories = CompilationPipeline.GetSystemAssemblyDirectories(assembly.compilerOptions.ApiCompatibilityLevel); Dictionary responseFilesData = assembly.compilerOptions.ResponseFiles.ToDictionary(x => x, x => m_AssemblyNameProvider.ParseResponseFile( x, ProjectDirectory, systemReferenceDirectories )); Dictionary responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any()) .ToDictionary(x => x.Key, x => x.Value); if (responseFilesWithErrors.Any()) { foreach (var error in responseFilesWithErrors) foreach (var valueError in error.Value.Errors) { Debug.LogError($"{error.Key} Parse Error : {valueError}"); } } return responseFilesData.Select(x => x.Value); } Dictionary GenerateAllAssetProjectParts() { Dictionary stringBuilders = new Dictionary(); foreach (string asset in m_AssemblyNameProvider.GetAllAssetPaths()) { // Exclude files coming from packages except if they are internalized. // TODO: We need assets from the assembly API if (!m_ShouldGenerateAll && IsInternalizedPackagePath(asset)) { continue; } string extension = Path.GetExtension(asset); if (IsSupportedExtension(extension) && ScriptingLanguage.None == ScriptingLanguageFor(extension)) { // Find assembly the asset belongs to by adding script extension and using compilation pipeline. var assemblyName = m_AssemblyNameProvider.GetAssemblyNameFromScriptPath(asset); if (string.IsNullOrEmpty(assemblyName)) { continue; } assemblyName = Path.GetFileNameWithoutExtension(assemblyName); if (!stringBuilders.TryGetValue(assemblyName, out var projectBuilder)) { projectBuilder = new StringBuilder(); stringBuilders[assemblyName] = projectBuilder; } projectBuilder.Append(" ").Append(k_WindowsNewline); } } var result = new Dictionary(); foreach (var entry in stringBuilders) result[entry.Key] = entry.Value.ToString(); return result; } bool IsInternalizedPackagePath(string file) { if (string.IsNullOrWhiteSpace(file)) { return false; } var packageInfo = m_AssemblyNameProvider.FindForAssetPath(file); if (packageInfo == null) { return false; } var packageSource = packageInfo.source; return packageSource != PackageSource.Embedded && packageSource != PackageSource.Local; } void SyncProject( Assembly assembly, Dictionary allAssetsProjectParts, IEnumerable responseFilesData, HashSet assemblyNames) { SyncProjectFileIfNotChanged(ProjectFile(assembly), ProjectText(assembly, allAssetsProjectParts, responseFilesData, assemblyNames)); } void SyncProjectFileIfNotChanged(string path, string newContents) { SyncFileIfNotChanged(path, newContents); } void SyncSolutionFileIfNotChanged(string path, string newContents) { SyncFileIfNotChanged(path, newContents); } void SyncFileIfNotChanged(string filename, string newContents) { if (m_FileIOProvider.Exists(filename)) { var currentContents = m_FileIOProvider.ReadAllText(filename); if (currentContents == newContents) { return; } } m_FileIOProvider.WriteAllText(filename, newContents); } string ProjectText( Assembly assembly, Dictionary allAssetsProjectParts, IEnumerable responseFilesData, HashSet assemblyNames) { var projectBuilder = new StringBuilder(); ProjectHeader(assembly, responseFilesData, projectBuilder); var references = new List(); var projectReferences = new List(); foreach (string file in assembly.sourceFiles) { if (!ShouldFileBePartOfSolution(file)) continue; var extension = Path.GetExtension(file).ToLower(); var fullFile = EscapedRelativePathFor(file); if (".dll" != extension) { projectBuilder.Append(" ").Append(k_WindowsNewline); } else { references.Add(fullFile); } } // Append additional non-script files that should be included in project generation. if (allAssetsProjectParts.TryGetValue(assembly.name, out var additionalAssetsForProject)) projectBuilder.Append(additionalAssetsForProject); var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r)); foreach (var reference in assembly.compiledAssemblyReferences.Union(responseRefs).Union(references)) { string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(ProjectDirectory, reference); AppendReference(fullReference, projectBuilder); } if (0 < assembly.assemblyReferences.Length) { projectBuilder.Append(" ").Append(k_WindowsNewline); projectBuilder.Append(" ").Append(k_WindowsNewline); foreach (Assembly reference in assembly.assemblyReferences) { var referencedProject = reference.outputPath; projectBuilder.Append(" ").Append(k_WindowsNewline); projectBuilder.Append(" {").Append(ProjectGuid(reference.name)).Append("}").Append(k_WindowsNewline); projectBuilder.Append(" ").Append(reference.name).Append("").Append(k_WindowsNewline); projectBuilder.Append(" ").Append(k_WindowsNewline); } } projectBuilder.Append(ProjectFooter()); return projectBuilder.ToString(); } static void AppendReference(string fullReference, StringBuilder projectBuilder) { //replace \ with / and \\ with / var escapedFullPath = SecurityElement.Escape(fullReference); escapedFullPath = escapedFullPath.Replace("\\\\", "/"); escapedFullPath = escapedFullPath.Replace("\\", "/"); projectBuilder.Append(" ").Append(k_WindowsNewline); projectBuilder.Append(" ").Append(escapedFullPath).Append("").Append(k_WindowsNewline); projectBuilder.Append(" ").Append(k_WindowsNewline); } public string ProjectFile(Assembly assembly) { var fileBuilder = new StringBuilder(assembly.name); fileBuilder.Append(".csproj"); return Path.Combine(ProjectDirectory, fileBuilder.ToString()); } public string SolutionFile() { return Path.Combine(ProjectDirectory, $"{m_ProjectName}.sln"); } void ProjectHeader( Assembly assembly, IEnumerable responseFilesData, StringBuilder builder ) { // TODO: .Concat(EditorUserBuildSettings.activeScriptCompilationDefines) GetProjectHeaderTemplate( builder, ProjectGuid(assembly.name), assembly.name, string.Join(";", new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()), assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe)); } static string GetSolutionText() { return string.Join("\r\n", @"", @"Microsoft Visual Studio Solution File, Format Version {0}", @"# Visual Studio {1}", @"{2}", @"Global", @" GlobalSection(SolutionConfigurationPlatforms) = preSolution", @" Debug|Any CPU = Debug|Any CPU", @" Release|Any CPU = Release|Any CPU", @" EndGlobalSection", @" GlobalSection(ProjectConfigurationPlatforms) = postSolution", @"{3}", @" EndGlobalSection", @" GlobalSection(SolutionProperties) = preSolution", @" HideSolutionNode = FALSE", @" EndGlobalSection", @"EndGlobal", @"").Replace(" ", "\t"); } static string GetProjectFooterTemplate() { return string.Join("\r\n", @" ", @" ", @" ", @"", @""); } static void GetProjectHeaderTemplate( StringBuilder builder, string assemblyGUID, string assemblyName, string defines, bool allowUnsafe ) { builder.Append(@"").Append(k_WindowsNewline); builder.Append(@"").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_TargetLanguageVersion).Append("").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" Debug").Append(k_WindowsNewline); builder.Append(@" AnyCPU").Append(k_WindowsNewline); builder.Append(@" ").Append(k_ProductVersion).Append("").Append(k_WindowsNewline); builder.Append(@" 2.0").Append(k_WindowsNewline); builder.Append(@" ").Append(EditorSettings.projectGenerationRootNamespace).Append("").Append(k_WindowsNewline); builder.Append(@" {").Append(assemblyGUID).Append("}").Append(k_WindowsNewline); builder.Append(@" Library").Append(k_WindowsNewline); builder.Append(@" Properties").Append(k_WindowsNewline); builder.Append(@" ").Append(assemblyName).Append("").Append(k_WindowsNewline); builder.Append(@" ").Append(k_TargetFrameworkVersion).Append("").Append(k_WindowsNewline); builder.Append(@" 512").Append(k_WindowsNewline); builder.Append(@" ").Append(k_BaseDirectory).Append("").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" true").Append(k_WindowsNewline); builder.Append(@" full").Append(k_WindowsNewline); builder.Append(@" false").Append(k_WindowsNewline); builder.Append(@" Temp\bin\Debug\").Append(k_WindowsNewline); builder.Append(@" ").Append(defines).Append("").Append(k_WindowsNewline); builder.Append(@" prompt").Append(k_WindowsNewline); builder.Append(@" 4").Append(k_WindowsNewline); builder.Append(@" 0169").Append(k_WindowsNewline); builder.Append(@" ").Append(allowUnsafe).Append("").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" pdbonly").Append(k_WindowsNewline); builder.Append(@" true").Append(k_WindowsNewline); builder.Append(@" Temp\bin\Release\").Append(k_WindowsNewline); builder.Append(@" prompt").Append(k_WindowsNewline); builder.Append(@" 4").Append(k_WindowsNewline); builder.Append(@" 0169").Append(k_WindowsNewline); builder.Append(@" ").Append(allowUnsafe).Append("").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" true").Append(k_WindowsNewline); builder.Append(@" true").Append(k_WindowsNewline); builder.Append(@" false").Append(k_WindowsNewline); builder.Append(@" false").Append(k_WindowsNewline); builder.Append(@" false").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); builder.Append(@" ").Append(k_WindowsNewline); } void SyncSolution(IEnumerable assemblies) { SyncSolutionFileIfNotChanged(SolutionFile(), SolutionText(assemblies)); } string SolutionText(IEnumerable assemblies) { var fileversion = "11.00"; var vsversion = "2010"; var relevantAssemblies = RelevantAssembliesForMode(assemblies); string projectEntries = GetProjectEntries(relevantAssemblies); string projectConfigurations = string.Join(k_WindowsNewline, relevantAssemblies.Select(i => GetProjectActiveConfigurations(ProjectGuid(i.name))).ToArray()); return string.Format(GetSolutionText(), fileversion, vsversion, projectEntries, projectConfigurations); } static IEnumerable RelevantAssembliesForMode(IEnumerable assemblies) { return assemblies.Where(i => ScriptingLanguage.CSharp == ScriptingLanguageFor(i)); } /// /// Get a Project("{guid}") = "MyProject", "MyProject.csproj", "{projectguid}" /// entry for each relevant language /// string GetProjectEntries(IEnumerable assemblies) { var projectEntries = assemblies.Select(i => string.Format( m_SolutionProjectEntryTemplate, SolutionGuid(i), i.name, Path.GetFileName(ProjectFile(i)), ProjectGuid(i.name) )); return string.Join(k_WindowsNewline, projectEntries.ToArray()); } /// /// Generate the active configuration string for a given project guid /// string GetProjectActiveConfigurations(string projectGuid) { return string.Format( m_SolutionProjectConfigurationTemplate, projectGuid); } string EscapedRelativePathFor(string file) { var projectDir = ProjectDirectory.Replace('/', '\\'); file = file.Replace('/', '\\'); var path = SkipPathPrefix(file, projectDir); var packageInfo = m_AssemblyNameProvider.FindForAssetPath(path.Replace('\\', '/')); if (packageInfo != null) { // We have to normalize the path, because the PackageManagerRemapper assumes // dir seperators will be os specific. var absolutePath = Path.GetFullPath(NormalizePath(path)).Replace('/', '\\'); path = SkipPathPrefix(absolutePath, projectDir); } return SecurityElement.Escape(path); } static string SkipPathPrefix(string path, string prefix) { if (path.StartsWith($@"{prefix}\")) return path.Substring(prefix.Length + 1); return path; } static string NormalizePath(string path) { if (Path.DirectorySeparatorChar == '\\') return path.Replace('/', Path.DirectorySeparatorChar); return path.Replace('\\', Path.DirectorySeparatorChar); } string ProjectGuid(string assembly) { return m_GUIDProvider.ProjectGuid(m_ProjectName, assembly); } string SolutionGuid(Assembly assembly) { return m_GUIDProvider.SolutionGuid(m_ProjectName, GetExtensionOfSourceFiles(assembly.sourceFiles)); } static string ProjectFooter() { return GetProjectFooterTemplate(); } static string GetProjectExtension() { return ".csproj"; } void WriteVSCodeSettingsFiles() { var vsCodeDirectory = Path.Combine(ProjectDirectory, ".vscode"); if (!m_FileIOProvider.Exists(vsCodeDirectory)) m_FileIOProvider.CreateDirectory(vsCodeDirectory); var vsCodeSettingsJson = Path.Combine(vsCodeDirectory, "settings.json"); if (!m_FileIOProvider.Exists(vsCodeSettingsJson)) m_FileIOProvider.WriteAllText(vsCodeSettingsJson, k_SettingsJson); } } public static class SolutionGuidGenerator { static MD5 mD5 = MD5CryptoServiceProvider.Create(); public static string GuidForProject(string projectName) { return ComputeGuidHashFor(projectName + "salt"); } public static string GuidForSolution(string projectName, string sourceFileExtension) { if (sourceFileExtension.ToLower() == "cs") // GUID for a C# class library: http://www.codeproject.com/Reference/720512/List-of-Visual-Studio-Project-Type-GUIDs return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC"; return ComputeGuidHashFor(projectName); } static string ComputeGuidHashFor(string input) { var hash = mD5.ComputeHash(Encoding.Default.GetBytes(input)); return new Guid(hash).ToString(); } } }