This commit is contained in:
2026-08-28 15:56:12 +01:00
commit 4d5f73e29c
7349 changed files with 664196 additions and 0 deletions
@@ -0,0 +1 @@
{"timestamp":1768993488,"signature":"PdFVNAs+vUghsSzZ/UDix40NtW3yt1oDq+VnqB5RLc5uaSxgCBFGhxBLdU1jo8VMN6raj+Xib/D8aFHlDC7q0RxIg6UOWbp9GFBgui2Cn9GadF8ykiRRdLp7vIG4OW1HUePQeHlYr84TqP0g4a20WrCVyQ5kMJN+l//YnRzg7I/B0qeugo6hWd1wwTHPAiny8qxlPmPz76bWlLn77w0+AA2Kb1FExKVPKe0WtLdmYnlGGeo1+C5d2p8/JMUrxvZFDuI/iUxKkNmHWbhkMeHa6/gn6ujylFp0z7RdI048+G4ii+Hfi5G4ZCCeMxHuF1tcNbgEhgYnN5ZrhKdB8e1wQOliqbHNjx1plYmcj9Mi3NJNHfgp5pWOisNM1NR990eG626UF2AvSs8CjDuT7joympCbtb7vxk8pymcckIY/+CVTHdiInq6jFL/yfO7+6m5TLmLIoHYx4YbdahZ7N8Lh068W8q8TJCvOVggKKaQFAmG+Yw4SJiMsoYEgePMIH9FU","publicKey":"LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQm9qQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FZOEFNSUlCaWdLQ0FZRUFzdUhXYUhsZ0I1cVF4ZEJjTlJKSAordHR4SmoxcVY1NTdvMlZaRE1XaXhYRVBkRTBEMVFkT1JIRXNSS1RscmplUXlERU83ZlNQS0ZwZ1A3MU5TTnJCCkFHM2NFSU45aHNQVDhOVmllZmdWem5QTkVMenFkVmdEbFhpb2VpUnV6OERKWFgvblpmU1JWKytwbk9ySTRibG4KS0twelJlNW14OTc1SjhxZ1FvRktKT0NNRlpHdkJMR2MxSzZZaEIzOHJFODZCZzgzbUovWjBEYkVmQjBxZm13cgo2ZDVFUXFsd0E5Y3JZT1YyV1VpWXprSnBLNmJZNzRZNmM1TmpBcEFKeGNiaTFOaDlRVEhUcU44N0ZtMDF0R1ZwCjVNd1pXSWZuYVRUemEvTGZLelR5U0pka0tldEZMVGdkYXpMYlpzUEE2aHBSK0FJRTJhc0tLTi84UUk1N3UzU2cKL2xyMnZKS1IvU2l5eEN1Q20vQWJkYnJMbXk0WjlSdm1jMGdpclA4T0lLQWxBRWZ2TzV5Z2hSKy8vd1RpTFlzUQp1SllDM0V2UE16ZGdKUzdGR2FscnFLZzlPTCsxVzROY05yNWdveVdSUUJ0cktKaWlTZEJVWmVxb0RvSUY5NHpCCndGbzJJT1JFdXFqcU51M3diMWZIM3p1dGdtalFra3IxVjJhd3hmcExLWlROQWdNQkFBRT0KLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg"}
@@ -0,0 +1,335 @@
# Code Editor Package for Visual Studio
## [2.0.27] - 2026-01-20
Integration:
- Fix Visual Studio Integration to properly wait for the solution to be opened.
Project generation:
- Disable Workspace-based development feature in `settings.json`.
- Ensure that we only have one `sln` or `slnx` file at a time.
- Properly handle filenames with special characters in `link` tags.
## [2.0.26] - 2025-12-16
Integration:
- Fix handling of asset-pipeline refresh-mode setting.
Project generation:
- Add `EnableOnDemandExcludedFolderLoading` capability when generating SDK-Style project.
## [2.0.25] - 2025-09-16
Internal:
- Fixes for release validation and release process.
## [2.0.24] - 2025-09-04
Integration:
- Remove support for `Visual Studio for Mac`. Please use `VS Code` going forward.
- Performance optimizations.
Project generation:
- Allow customization of `langversion` when using a `rsp` file.
- Move to `slnx` solution generation when using `SDK-Style` projects.
- Both `VS Code` and `Visual Studio 2026` are now using `SDK-Style` projects by default.
## [2.0.23] - 2025-02-03
Integration:
- Monitor `additionalfile` extension by default.
- Try opening a Visual Studio Code workspace if there's one (`.code-workspace` file in the Unity project).
Project generation:
- Identify `asset`, `meta`, `prefab` and `unity` files as `yaml` (Visual Studio Code).
- Add `sln`/`csproj` file nesting (Visual Studio Code).
- Improve SDK style project generation.
## [2.0.22] - 2023-10-03
Integration:
- Add support for `XDG_DATA_DIRS` and `.desktop` files on Linux for `VS Code` discovery.
- Use compile-time platform-specifics instead of using runtime conditions.
Project generation:
- Suppress `USG0001` warnings.
- Mark referenced assemblies as private (to not copy extra files to output directory when building).
- Add Unity capability to SDK-Style projects.
- Prevent circular dependency errors with SDK-Style projects.
## [2.0.21] - 2023-09-05
Integration:
- Only disable the legacy `com.unity.ide.vscode` package going forward.
- Fix json parsing issues with specific non-UTF code pages.
Project generation:
- Target `netstandard2.1` instead of `netstandard2.0`.
- Set `defaultSolution` in `settings.json`.
- Remove `files.exclude` entries for root `csproj` and `sln` files in `settings.json` when needed.
- Add `vstuc` launch configuration to `launch.json` when needed.
- Add `visualstudiotoolsforunity.vstuc` entry to `extensions.json` when needed.
- You can prevent the package from patching those configuration files by creating a `.vscode/.vstupatchdisable` file.
## [2.0.20] - 2023-06-27
Integration:
- Internal API refactoring.
- Add support for Visual Studio Code.
Project generation:
- Add support for Sdk Style project generation.
- Fix an issue related to missing properties with 2021.3.
## [2.0.18] - 2023-03-17
Integration:
- Performance improvements with `EditorApplication.update` callbacks.
Project generation:
- Add extra compiler options for analyzers and source generators.
## [2.0.17] - 2022-12-06
Integration:
- Fix rare deadlocks while discovering or launching Visual Studio on Windows.
- Improve launching Visual Studio on macOs.
Project generation:
- Include analyzers from response files.
- Update supported C# versions.
- Performance improvements.
## [2.0.16] - 2022-06-08
Integration:
- Prevent ADB Refresh while being in safe-mode with a URP project
- Fixed an issue keeping the progress bar visible even after opening a script with Visual Studio.
## [2.0.15] - 2022-03-21
Integration:
- Improved project generation performance.
- Added support for keeping file/folder structure when working with external packages.
- Fixed project generation not being refreshed when selecting Visual Studio as the preferred external editor.
## [2.0.14] - 2022-01-14
Integration:
- Remove package version checking.
## [2.0.13] - 2022-01-12
Integration:
- Fixed wrong path to analyzers in generated projects when using external packages.
- Fixed selective project generation not creating Analyzer/LangVersion nodes.
- Fixed asmdef references with Player projects.
Documentation:
- Added new documentation including ToC, overview, how to use and images.
## [2.0.12] - 2021-10-20
Integration:
- Do not block asset opening when only a VS instance without a loaded solution is found.
- Only check package version once per Unity session.
- Improved support for Visual Studio For Mac 2022.
## [2.0.11] - 2021-07-01
Integration:
- Added support for Visual Studio and Visual Studio For Mac 2022.
- Fixed an issue when the package was enabled for background processes.
Project generation:
- Use absolute paths for Analyzers and rulesets.
## [2.0.10] - 2021-06-10
Project generation:
- Improved project generation performance when a file is moved, deleted or modified.
Integration:
- Improved Inner-loop performance by avoiding to call the package manager when looking up `vswhere` utility.
- Fixed a network issue preventing the communication between Visual Studio and Unity on Windows.
## [2.0.9] - 2021-05-04
Project generation:
- Added support for CLI.
Integration:
- Improved performance when discovering Visual Studio installations.
- Warn when legacy assemblies are present in the project.
- Warn when the package version is not up-to-date.
## [2.0.8] - 2021-04-09
Project generation:
- Improved generation performance (especially with DOTS enabled projects).
- Improved stability.
- Updated Analyzers lookup strategy.
- Fixed .vsconfig file not generated when using "regenerate all".
Integration:
- Improved automation plugins.
Documentation:
- Open sourced automation plugins.
## [2.0.7] - 2021-02-02
Integration:
- Remove `com.unity.nuget.newtonsoft-json` dependency in favor of the built-in JsonUtility for the VS Test Runner.
## [2.0.6] - 2021-01-20
Project generation:
- Improved language version detection.
Integration:
- Added support for the VS Test Runner.
- Added initial support for displaying asset usage.
- Fixed remaining issues with special characters in file/path.
## [2.0.5] - 2020-10-30
Integration:
- Disable legacy pdb symbol checking for Unity packages.
## [2.0.4] - 2020-10-15
Project generation:
- Added support for embedded Roslyn analyzer DLLs and ruleset files.
- Warn the user when the opened script is not part of the generation scope.
- Warn the user when the selected Visual Studio installation is not found.
- Generate a .vsconfig file to ensure Visual Studio installation is compatible.
Integration:
- Fix automation issues on MacOS, where a new Visual Studio instance is opened every time.
## [2.0.3] - 2020-09-09
Project generation:
- Added C#8 language support.
- Added `UnityProjectGeneratorVersion` property.
- Local and Embedded packages are now selected by default for generation.
- Added support for asmdef root namespace.
Integration:
- When the user disabled auto-refresh in Unity, do not try to force refresh the Asset database.
- Fix Visual Studio detection issues with languages using special characters.
## [2.0.2] - 2020-05-27
- Added support for solution folders.
- Only bind the messenger when the VS editor is selected.
- Warn when unable to create the messenger.
- Fixed an initialization issue triggering legacy code generation.
- Allow package source in assembly to be generated when referenced from asmref.
## [2.0.1] - 2020-03-19
- When Visual Studio installation is compatible with C# 8.0, setup the language version to not prompt the user with unsupported constructs. (So far Unity only supports C# 7.3).
- Use Unity's `TypeCache` to improve project generation speed.
- Properly check for a managed assembly before displaying a warning regarding legacy PDB usage.
- Add support for selective project generation (embedded, local, registry, git, builtin, player).
## [2.0.0] - 2019-11-06
- Improved Visual Studio and Visual Studio for Mac automatic discovery.
- Added support for the VSTU messaging system (start/stop features from Visual Studio).
- Added support for solution roundtrip (preserves references to external projects and solution properties).
- Added support for VSTU Analyzers (requires Visual Studio 2019 16.3, Visual Studio for Mac 8.3).
- Added a warning when using legacy pdb symbol files.
- Fixed issues while Opening Visual Studio on Windows.
- Fixed issues while Opening Visual Studio on Mac.
## [1.1.1] - 2019-05-29
- Fix Bridge assembly loading with non VS2017 editors.
## [1.1.0] - 2019-05-27
- Move internal extension handling to package.
## [1.0.11] - 2019-05-21
- Fix detection of visual studio for mac installation.
## [1.0.10] - 2019-05-04
- Fix ignored comintegration executable.
## [1.0.9] - 2019-03-05
- Updated MonoDevelop support, to pass correct arguments, and not import VSTU plugin.
- Use release build of COMIntegration for Visual Studio.
## [1.0.7] - 2019-04-30
- Ensure asset database is refreshed when generating csproj and solution files.
## [1.0.6] - 2019-04-27
- Add support for generating all csproj files.
## [1.0.5] - 2019-04-18
- Fix relative package paths.
- Fix opening editor on mac.
## [1.0.4] - 2019-04-12
- Fixing null reference issue for callbacks to `AssetPostProcessor`.
- Ensure `Path.GetFullPath` does not get an empty string.
## [1.0.3] - 2019-01-01
### This is the first release of *Unity Package visualstudio_editor*.
- Using the newly created api to integrate Visual Studio with Unity.
@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 6022bdd5b2896a54f94123b812705321
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,6 @@
# Contributing
## All contributions are subject to the [Unity Contribution Agreement(UCA)](https://unity3d.com/legal/licenses/Unity_Contribution_Agreement) and [Microsoft Contributor License Agreement (CLA)](https://cla.opensource.microsoft.com/)
By making a pull request, you are confirming agreement to the terms and conditions of the UCA and CLA, including that your contributions are your original creation and that you have complete right and authority to make your contributions.
## Once you have a change ready following these ground rules. Simply make a pull request
@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: cd78ce5b75b8be84d8b94cd99903161f
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Binary file not shown.

After

Width:  |  Height:  |  Size: 357 KiB

@@ -0,0 +1,4 @@
# Code Editor Package for Visual Studio
This package is not intended to be modified by users.
Nor does it provide any api intended to be included in user projects.
@@ -0,0 +1,2 @@
* [About Visual Studio Editor](index.md)
* [Using the Visual Studio Editor package](using-visual-studio-editor.md)
@@ -0,0 +1,30 @@
# Code Editor Package for Visual Studio
## About Visual Studio Editor
The Visual Studio Editor package provides the Unity Editor with support for Unity-specific features from the [Visual Studio Tools for Unity](https://docs.microsoft.com/en-us/visualstudio/gamedev/unity/get-started/visual-studio-tools-for-unity) extension in [Visual Studio](https://visualstudio.microsoft.com/) and the [Unity for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=visualstudiotoolsforunity.vstuc) extension in [Visual Studio Code](https://code.visualstudio.com/). These include IntelliSense auto-complete suggestions, C# editing, and debugging.
## Installation
This package is a built-in package and installed by default.
**Note**: If you’re using a version of the Unity Editor before 2019.4, you’ll need to install this package through the package manager.
## Requirements
This version of the Visual Studio Editor package is compatible with the following versions of the Unity Editor:
* 2019.4 and later
To use this package, you must have the following third-party products installed:
* **On Windows**: Visual Studio 2019 version 16.9 or newer with [Visual Studio Tools for Unity](https://docs.microsoft.com/en-us/visualstudio/gamedev/unity/get-started/visual-studio-tools-for-unity) 4.0.9 or newer.
* **On macOS**: Visual Studio Code with [Unity for Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=visualstudiotoolsforunity.vstuc) 0.9.0 or newer.
For more information on using Visual Studio with Unity, refer to Microsoft's [Visual Studio Tools for Unity](https://docs.microsoft.com/en-us/visualstudio/gamedev/unity/get-started/visual-studio-tools-for-unity) documentation.
For more information on using VS Code with Unity, refer to the Visual Studio Code [Unity development with VS code](https://code.visualstudio.com/docs/other/unity) documentation.
## Submitting issues
This package is maintained by Microsoft and Unity. Submit issues directly from the **Help** menu in Visual Studio (**Help** > **Submit Feedback** > **Report a Problem**) or Visual Studio Code (**Help** > **Report an Issue**). Unity will make this package accessible to the public on GitHub in the future.
@@ -0,0 +1,23 @@
# Using the Visual Studio Editor package
To use the package, go to **Edit** > **Preferences** > **External Tools** > **External Script Editor** and select the version of **Visual Studio** you have installed. When you select this option, the window reloads and displays settings that control production of .csproj files.
![External Tools tab in the Preferences window](Images/vs-external-tools.png)
## Generate .csproj files
Each setting in the table below enables or disables the production of .csproj files for a different type of package.When you click **Regenerate project files**, Unity updates the existing .csproj files and creates the necessary new ones based on the settings you choose.
These settings control whether to generate .csproj files for any installed packages. For more information on how to install packages, see [Adding and removing packages](https://docs.unity3d.com/Manual/upm-ui-actions.html).
| **Property** | **Description** |
|---|---|
| **Embedded packages** | Any package that appears under your project’s Packages folder is an embedded package. An embedded package is not necessarily built-in; you can create your own packages and embed them inside your project. This setting is enabled by default.<br/><br/>For more information on embedded packages, see [Embedded dependencies](https://docs.unity3d.com/Manual/upm-embed.html). |
| **Local packages** | Any package that you install from a local repository stored on your machine, but from outside of your Unity project. This setting is enabled by default. |
| **Registry packages** | Any package that you install from either the official Unity registry or a custom registry. Packages in the Unity registry are available to install directly from the Package Manager. For more information about the Unity package registry, see The Package Registry section of the [Unity Package Manager documentation](https://docs.unity3d.com/Packages/com.unity.package-manager-ui@1.8/manual/index.html#PackManRegistry). <br/><br/>For information on how to create and use custom registries in addition to the Unity registry, see [Scoped package registries](https://docs.unity3d.com/Manual/upm-scoped.html). |
| **Git packages** | Any package you install directly from a Git repository using a URL. |
| **Built-in packages** | Any package that is already installed as part of the default Unity installation. |
| **Tarball packages** | Any package you install from a GZip tarball archive on the local machine, outside of your Unity project. |
| **Unknown packages** | Any package which Unity cannot determine an origin for. This could be because the package doesn’t list its origin, or that Unity doesn’t recognize the origin listed. |
| **Player projects** | For each player project, generate an additional .csproj file named ‘originalProjectName.Player.csproj’. This allows different project types to have their code included in Visual Studio’s systems, such as assembly definitions or testing suites. |
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 4a707af59e3522d43afe34dfc4429b86
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,4 @@
using System.Runtime.CompilerServices;
[assembly:InternalsVisibleTo("Unity.VisualStudio.EditorTests")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: d791d407901442e49862d3aa783ce8af
timeCreated: 1602756877
@@ -0,0 +1,86 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Threading;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class AsyncOperation<T>
{
private readonly Func<T> _producer;
private readonly Func<Exception, T> _exceptionHandler;
private readonly Action _finalHandler;
private readonly ManualResetEventSlim _resetEvent;
private T _result;
private Exception _exception;
private AsyncOperation(Func<T> producer, Func<Exception, T> exceptionHandler, Action finalHandler)
{
_producer = producer;
_exceptionHandler = exceptionHandler;
_finalHandler = finalHandler;
_resetEvent = new ManualResetEventSlim(initialState: false);
}
public static AsyncOperation<T> Run(Func<T> producer, Func<Exception, T> exceptionHandler = null, Action finalHandler = null)
{
var task = new AsyncOperation<T>(producer, exceptionHandler, finalHandler);
task.Run();
return task;
}
private void Run()
{
ThreadPool.QueueUserWorkItem(_ =>
{
try
{
_result = _producer();
}
catch (Exception e)
{
_exception = e;
if (_exceptionHandler != null)
{
_result = _exceptionHandler(e);
}
}
finally
{
_finalHandler?.Invoke();
_resetEvent.Set();
}
});
}
private void CheckCompletion()
{
if (!_resetEvent.IsSet)
_resetEvent.Wait();
}
public T Result
{
get
{
CheckCompletion();
return _result;
}
}
public Exception Exception
{
get
{
CheckCompletion();
return _exception;
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: c6c8b2f6152bd1348ae35f9f95719f75
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 36422aa067e092e45b9820da2ee3e728
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,40 @@
#pragma once
#include <OleAuto.h>
struct BStrHolder
{
BStrHolder() :
m_Str(NULL)
{
}
BStrHolder(const wchar_t* str) :
m_Str(SysAllocString(str))
{
}
~BStrHolder()
{
if (m_Str != NULL)
SysFreeString(m_Str);
}
operator BSTR() const
{
return m_Str;
}
BSTR* operator&()
{
if (m_Str != NULL)
{
SysFreeString(m_Str);
m_Str = NULL;
}
return &m_Str;
}
private:
BSTR m_Str;
};
@@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 3.15)
project(com)
set(SOURCES
COMIntegration.cpp
BStrHolder.h
ComPtr.h
dte80a.tlh
)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -Wall")
add_executable(COMIntegration ${SOURCES})
set_property(TARGET COMIntegration PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded")
target_link_libraries(COMIntegration Shlwapi.lib)
@@ -0,0 +1,490 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
#include <iostream>
#include <sstream>
#include <string>
#include <functional>
#include <filesystem>
#include <windows.h>
#include <shlwapi.h>
#include <fcntl.h>
#include <io.h>
#include "BStrHolder.h"
#include "ComPtr.h"
#include "dte80a.tlh"
constexpr int RETRY_INTERVAL_MS = 150;
constexpr int TIMEOUT_MS = 10000;
// Often a DTE call made to Visual Studio can fail after Visual Studio has just started. Usually the
// return value will be RPC_E_CALL_REJECTED, meaning that Visual Studio is probably busy on another
// thread. This types filter the RPC messages and retries to send the message until VS accepts it.
class CRetryMessageFilter : public IMessageFilter
{
private:
static bool ShouldRetryCall(DWORD dwTickCount, DWORD dwRejectType)
{
if (dwRejectType == SERVERCALL_RETRYLATER || dwRejectType == SERVERCALL_REJECTED) {
return dwTickCount < TIMEOUT_MS;
}
return false;
}
win::ComPtr<IMessageFilter> currentFilter;
public:
CRetryMessageFilter()
{
HRESULT hr = CoRegisterMessageFilter(this, &currentFilter);
_ASSERT(SUCCEEDED(hr));
}
~CRetryMessageFilter()
{
win::ComPtr<IMessageFilter> messageFilter;
HRESULT hr = CoRegisterMessageFilter(currentFilter, &messageFilter);
_ASSERT(SUCCEEDED(hr));
}
// IUnknown methods
IFACEMETHODIMP QueryInterface(REFIID riid, void** ppv)
{
static const QITAB qit[] =
{
QITABENT(CRetryMessageFilter, IMessageFilter),
{ 0 },
};
return QISearch(this, qit, riid, ppv);
}
IFACEMETHODIMP_(ULONG) AddRef()
{
return 0;
}
IFACEMETHODIMP_(ULONG) Release()
{
return 0;
}
DWORD STDMETHODCALLTYPE HandleInComingCall(DWORD dwCallType, HTASK htaskCaller, DWORD dwTickCount, LPINTERFACEINFO lpInterfaceInfo)
{
if (currentFilter)
return currentFilter->HandleInComingCall(dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo);
return SERVERCALL_ISHANDLED;
}
DWORD STDMETHODCALLTYPE RetryRejectedCall(HTASK htaskCallee, DWORD dwTickCount, DWORD dwRejectType)
{
if (ShouldRetryCall(dwTickCount, dwRejectType))
return RETRY_INTERVAL_MS;
if (currentFilter)
return currentFilter->RetryRejectedCall(htaskCallee, dwTickCount, dwRejectType);
return (DWORD)-1;
}
DWORD STDMETHODCALLTYPE MessagePending(HTASK htaskCallee, DWORD dwTickCount, DWORD dwPendingType)
{
if (currentFilter)
return currentFilter->MessagePending(htaskCallee, dwTickCount, dwPendingType);
return PENDINGMSG_WAITDEFPROCESS;
}
};
static void DisplayProgressbar() {
std::wcout << "displayProgressBar" << std::endl;
}
static void ClearProgressbar() {
std::wcout << "clearprogressbar" << std::endl;
}
inline std::wstring QuoteString(const std::wstring& str)
{
return L"\"" + str + L"\"";
}
static std::wstring ErrorCodeToMsg(DWORD code)
{
LPWSTR msgBuf = nullptr;
if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&msgBuf, 0, nullptr))
{
return L"Unknown error";
}
else
{
std::wstring message(msgBuf);
LocalFree(msgBuf);
return message;
}
}
// Get an environment variable
static std::wstring GetEnvironmentVariableValue(const std::wstring_view& variableName) {
DWORD currentBufferSize = MAX_PATH;
std::wstring variableValue;
variableValue.resize(currentBufferSize);
DWORD requiredBufferSize = GetEnvironmentVariableW(variableName.data(), variableValue.data(), currentBufferSize);
if (requiredBufferSize == 0) {
// Environment variable probably does not exist.
return std::wstring();
}
if (currentBufferSize < requiredBufferSize) {
variableValue.resize(requiredBufferSize);
if (GetEnvironmentVariableW(variableName.data(), variableValue.data(), currentBufferSize) == 0)
return std::wstring();
}
variableValue.resize(requiredBufferSize);
return variableValue;
}
static bool StartVisualStudioProcess(
const std::filesystem::path &visualStudioExecutablePath,
const std::filesystem::path &solutionPath,
DWORD *dwProcessId) {
STARTUPINFOW si = { sizeof(si) };
PROCESS_INFORMATION pi = {};
const std::wstring startingDirectory = visualStudioExecutablePath.parent_path();
// Build the command line that is passed as the argv of the VS process
// argv[0] must be the quoted full path to the VS exe
std::wstringstream commandLineStream;
commandLineStream << QuoteString(visualStudioExecutablePath) << L" ";
const std::wstring vsArgsWide = GetEnvironmentVariableValue(L"UNITY_VS_ARGS");
if (!vsArgsWide.empty())
commandLineStream << vsArgsWide << L" ";
commandLineStream << QuoteString(solutionPath);
std::wstring commandLine = commandLineStream.str();
std::wcout << "Starting Visual Studio process with: " << commandLine << std::endl;
const BOOL result = CreateProcessW(
visualStudioExecutablePath.c_str(), // Full path to VS, must not be quoted
commandLine.data(), // Command line, as passed as argv, separate arguments must be quoted if they contain spaces
nullptr, // Process handle not inheritable
nullptr, // Thread handle not inheritable
false, // Set handle inheritance to FALSE
0, // No creation flags
nullptr, // Use parent's environment block
startingDirectory.c_str(), // starting directory set to the VS directory
&si,
&pi);
if (!result) {
DWORD error = GetLastError();
std::wcout << "Starting Visual Studio process failed: " << ErrorCodeToMsg(error) << std::endl;
return false;
}
*dwProcessId = pi.dwProcessId;
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
return true;
}
static bool
MonikerIsVisualStudioProcess(const win::ComPtr<IMoniker> &moniker, const win::ComPtr<IBindCtx> &bindCtx, const DWORD dwProcessId = 0) {
LPOLESTR oleMonikerName;
if (FAILED(moniker->GetDisplayName(bindCtx, nullptr, &oleMonikerName)))
return false;
std::wstring monikerName(oleMonikerName);
CoTaskMemFree(oleMonikerName);
// VisualStudio Moniker is "!VisualStudio.DTE.$Version:$PID"
// Example "!VisualStudio.DTE.14.0:1234"
if (monikerName.find(L"!VisualStudio.DTE") != 0)
return false;
if (dwProcessId == 0)
return true;
const std::wstring suffix = L":" + std::to_wstring(dwProcessId);
return monikerName.length() - suffix.length() == monikerName.find(suffix);
}
static win::ComPtr<EnvDTE::_DTE> FindVisualStudio(
const DWORD pid,
const std::function<bool(const win::ComPtr<EnvDTE::_DTE>&)> predicate)
{
CRetryMessageFilter retryMessageFilter;
win::ComPtr<IRunningObjectTable> ROT;
if (FAILED(GetRunningObjectTable(0, &ROT)))
return nullptr;
win::ComPtr<IBindCtx> bindCtx;
if (FAILED(CreateBindCtx(0, &bindCtx)))
return nullptr;
win::ComPtr<IEnumMoniker> enumMoniker;
if (FAILED(ROT->EnumRunning(&enumMoniker)))
return nullptr;
win::ComPtr<IMoniker> moniker;
ULONG monikersFetched = 0;
while (SUCCEEDED(enumMoniker->Next(1, &moniker, &monikersFetched)) && monikersFetched) {
if (!MonikerIsVisualStudioProcess(moniker, bindCtx, pid))
continue;
win::ComPtr<IUnknown> punk;
if (FAILED(ROT->GetObject(moniker, &punk)))
continue;
win::ComPtr<EnvDTE::_DTE> dte;
punk.As(&dte);
if (!dte)
continue;
if (!predicate || predicate(dte))
return dte;
}
return nullptr;
}
static win::ComPtr<EnvDTE::_DTE> FindRunningVisualStudioWithSolution(
const std::filesystem::path &visualStudioExecutablePath,
const std::filesystem::path &solutionPath)
{
return FindVisualStudio(0, [&](const win::ComPtr<EnvDTE::_DTE>& dte) {
CRetryMessageFilter retryMessageFilter;
// Get the executable path of this running instance.
BStrHolder visualStudioFullName;
if (FAILED(dte->get_FullName(&visualStudioFullName)))
return false;
const std::filesystem::path currentVisualStudioExecutablePath = std::wstring(visualStudioFullName);
// Ask for its current solution.
win::ComPtr<EnvDTE::_Solution> solution;
if (FAILED(dte->get_Solution(&solution)))
return false;
// Get the name of that solution.
BStrHolder solutionFullName;
if (FAILED(solution->get_FullName(&solutionFullName)))
return false;
const std::filesystem::path currentSolutionPath = std::wstring(solutionFullName);
if (currentSolutionPath.empty())
return false;
std::wcout << "Visual Studio opened on " << currentSolutionPath.wstring() << std::endl;
// If the name matches the solution we want to open and we have a Visual Studio installation path to use and this one matches that path, then use it.
// If we don't have a Visual Studio installation path to use, just use this solution.
if (!std::filesystem::equivalent(currentSolutionPath, solutionPath))
return false;
std::wcout << "We found a running Visual Studio session with the solution open." << std::endl;
if (!visualStudioExecutablePath.empty()) {
if (std::filesystem::equivalent(currentVisualStudioExecutablePath, visualStudioExecutablePath)) {
return true;
} else {
std::wcout << "This running Visual Studio session does not seem to be the version requested in the user preferences. We will keep looking." << std::endl;
return false;
}
} else {
std::wcout << "We're not sure which version of Visual Studio was requested in the user preferences. We will use this running session." << std::endl;
return true;
}
});
}
static win::ComPtr<EnvDTE::_DTE> FindRunningVisualStudioWithPID(const DWORD dwProcessId) {
return FindVisualStudio(dwProcessId, nullptr);
}
// Waits for the solution to be opened, including SDK-style (CPS) projects.
// CPS projects load asynchronously after the solution is opened, and VS may restore
// the previous window state when they finish loading. This function polls until
// the solution reports as open
static bool WaitForSolutionOpened(const win::ComPtr<EnvDTE::_DTE> &dte) {
CRetryMessageFilter retryMessageFilter;
int timeWaited = 0;
constexpr int SOLUTION_LOAD_TIMEOUT_MS = 60000;
while (timeWaited < SOLUTION_LOAD_TIMEOUT_MS) {
std::wcout << "Waiting for solution to be opened..." << std::endl;
win::ComPtr<EnvDTE::_Solution> solution;
if (FAILED(dte->get_Solution(&solution)) || !solution) {
Sleep(RETRY_INTERVAL_MS);
timeWaited += RETRY_INTERVAL_MS;
continue;
}
// Check if solution is open
VARIANT_BOOL isOpen = VARIANT_FALSE;
if (FAILED(solution->get_IsOpen(&isOpen)) || isOpen == VARIANT_FALSE) {
Sleep(RETRY_INTERVAL_MS);
timeWaited += RETRY_INTERVAL_MS;
continue;
}
return true;
}
std::wcout << "Timeout waiting for solution to be opened." << std::endl;
return false;
}
static bool HaveRunningVisualStudioOpenFile(const win::ComPtr<EnvDTE::_DTE> &dte, const std::filesystem::path &filename, int line) {
const BStrHolder bstrFileName(filename.c_str());
const BStrHolder bstrKind(L"{00000000-0000-0000-0000-000000000000}"); // EnvDTE::vsViewKindPrimary
win::ComPtr<EnvDTE::Window> window = nullptr;
CRetryMessageFilter retryMessageFilter;
if (!filename.empty()) {
std::wcout << "Getting operations API from the Visual Studio session." << std::endl;
win::ComPtr<EnvDTE::ItemOperations> item_ops;
if (FAILED(dte->get_ItemOperations(&item_ops)))
return false;
std::wcout << "Waiting for the Visual Studio session to open the file: " << filename.wstring() << "." << std::endl;
if (FAILED(item_ops->OpenFile(bstrFileName, bstrKind, &window)))
return false;
if (line > 0) {
win::ComPtr<IDispatch> selection_dispatch;
if (window && SUCCEEDED(window->get_Selection(&selection_dispatch))) {
win::ComPtr<EnvDTE::TextSelection> selection;
if (selection_dispatch &&
SUCCEEDED(selection_dispatch->QueryInterface(__uuidof(EnvDTE::TextSelection), &selection)) &&
selection) {
selection->GotoLine(line, false);
selection->EndOfLine(false);
}
}
}
}
window = nullptr;
if (SUCCEEDED(dte->get_MainWindow(&window))) {
// Allow the DTE to make its main window the foreground
HWND hWnd;
window->get_HWnd((long*)&hWnd);
DWORD processID;
if (GetWindowThreadProcessId(hWnd, &processID) != 0)
AllowSetForegroundWindow(processID);
// Activate() set the window to visible and active (blinks in taskbar)
window->Activate();
}
return true;
}
static bool VisualStudioOpenFile(
const std::filesystem::path &visualStudioExecutablePath,
const std::filesystem::path &solutionPath,
const std::filesystem::path &filename,
int line)
{
win::ComPtr<EnvDTE::_DTE> dte = nullptr;
std::wcout << "Looking for a running Visual Studio session." << std::endl;
// TODO: If path does not exist pass empty, which will just try to match all windows with solution
dte = FindRunningVisualStudioWithSolution(visualStudioExecutablePath, solutionPath);
if (!dte) {
std::wcout << "No appropriate running Visual Studio session not found, creating a new one." << std::endl;
DisplayProgressbar();
DWORD dwProcessId;
if (!StartVisualStudioProcess(visualStudioExecutablePath, solutionPath, &dwProcessId)) {
ClearProgressbar();
return false;
}
int timeWaited = 0;
while (timeWaited < TIMEOUT_MS) {
dte = FindRunningVisualStudioWithPID(dwProcessId);
if (dte)
break;
std::wcout << "Retrying to acquire DTE" << std::endl;
Sleep(RETRY_INTERVAL_MS);
timeWaited += RETRY_INTERVAL_MS;
}
ClearProgressbar();
if (!dte)
return false;
WaitForSolutionOpened(dte);
}
else {
std::wcout << "Using the existing Visual Studio session." << std::endl;
}
return HaveRunningVisualStudioOpenFile(dte, filename, line);
}
int wmain(int argc, wchar_t* argv[]) {
// We need this to properly display UTF16 text on the console
_setmode(_fileno(stdout), _O_U16TEXT);
if (argc != 3 && argc != 5) {
std::wcerr << argc << ": wrong number of arguments\n" << "Usage: com.exe installationPath solutionPath [fileName lineNumber]" << std::endl;
for (int i = 0; i < argc; i++) {
std::wcerr << argv[i] << std::endl;
}
return EXIT_FAILURE;
}
if (FAILED(CoInitialize(nullptr))) {
std::wcerr << "CoInitialize failed." << std::endl;
return EXIT_FAILURE;
}
const std::filesystem::path visualStudioExecutablePath = std::filesystem::absolute(argv[1]);
const std::filesystem::path solutionPath = std::filesystem::absolute(argv[2]);
std::filesystem::path fileName = L"";
int lineNumber = -1;
if (argc == 5) {
fileName = std::filesystem::absolute(argv[3]);
lineNumber = std::stoi(argv[4]);
}
VisualStudioOpenFile(visualStudioExecutablePath, solutionPath, fileName, lineNumber);
CoUninitialize();
return EXIT_SUCCESS;
}
@@ -0,0 +1,186 @@
#pragma once
namespace win
{
template<typename T>
class ComPtr;
template<typename T>
class ComPtrRef
{
private:
ComPtr<T>& m_ComPtr;
ComPtrRef(ComPtr<T>& comPtr) :
m_ComPtr(comPtr)
{
}
friend class ComPtr<T>;
public:
inline operator T**()
{
return m_ComPtr.ReleaseAndGetAddressOf();
}
inline operator void**()
{
return reinterpret_cast<void**>(m_ComPtr.ReleaseAndGetAddressOf());
}
inline T* operator*() throw ()
{
return m_ComPtr;
}
};
template<typename T>
class ComPtr
{
private:
T *ptr;
public:
inline ComPtr(void) : ptr(NULL) {}
inline ~ComPtr(void) { this->Free(); }
ComPtr(T *ptr)
{
if (NULL != (this->ptr = ptr))
{
this->ptr->AddRef();
}
}
ComPtr(const ComPtr &ptr)
{
if (NULL != (this->ptr = ptr.ptr))
{
this->ptr->AddRef();
}
}
inline bool operator!() const
{
return (NULL == this->ptr);
}
inline operator T*() const { return this->ptr; }
inline T *operator->() const
{
//_assert(NULL != this->ptr);
return this->ptr;
}
inline T &operator*()
{
//_assert(NULL != this->ptr);
return *this->ptr;
}
inline ComPtrRef<T> operator&()
{
return ComPtrRef<T>(*this);
}
const ComPtr &operator=(T *ptr)
{
if (this->ptr != ptr)
{
this->Free();
if (NULL != (this->ptr = ptr))
{
this->ptr->AddRef();
}
}
return *this;
}
const ComPtr &operator=(const ComPtr &ptr)
{
if (this->ptr != ptr.ptr)
{
this->Free();
if (NULL != (this->ptr = ptr.ptr))
{
this->ptr->AddRef();
}
}
return *this;
}
void Free(void)
{
if (NULL != this->ptr)
{
this->ptr->Release();
this->ptr = NULL;
}
}
inline T** ReleaseAndGetAddressOf()
{
Free();
return &ptr;
}
template<typename U>
inline HRESULT As(ComPtrRef<U> p) const throw ()
{
return ptr->QueryInterface(__uuidof(U), p);
}
inline bool operator==(std::nullptr_t) const
{
return this->ptr == nullptr;
}
template<typename U>
inline bool operator==(U* other)
{
if (ptr == nullptr || other == nullptr)
return ptr == other;
ComPtr<IUnknown> meUnknown;
ComPtr<IUnknown> otherUnknown;
if (FAILED(this->ptr->QueryInterface(__uuidof(IUnknown), &meUnknown)))
return false;
if (FAILED(other->QueryInterface(__uuidof(IUnknown), &otherUnknown)))
return false;
return static_cast<IUnknown*>(meUnknown) == static_cast<IUnknown*>(otherUnknown);
}
template<typename U>
inline bool operator==(ComPtr<U>& other)
{
return *this == static_cast<U*>(other);
}
inline bool operator!=(std::nullptr_t) const
{
return this->ptr != nullptr;
}
template<typename U>
inline bool operator!=(U* other)
{
return !(*this == other);
}
template<typename U>
inline bool operator!=(ComPtr<U>& other)
{
return *this != static_cast<U*>(other);
}
};
}
@@ -0,0 +1,9 @@
Direct style:
cl /EHsc /std:c++17 COMIntegration.cpp /link Shlwapi.lib /out:"..\Release\COMIntegration.exe"
For a debug build with PDB:
cl /EHsc /std:c++17 /Z7 /DEBUG:FULL COMIntegration.cpp /link Shlwapi.lib /out:"..\Release\COMIntegration.exe"
CMake style:
cmake ../COMIntegration~ -B ./build
cmake --build ./build --config=release -- /p:OutDir=..
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 41b2d972bdac29e4a89ef08b3b52c248
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: cb67edc1800c2ec4ba8dfb1cf0dfc84a
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,88 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Linq;
using Unity.CodeEditor;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class Cli
{
internal static void Log(string message)
{
// Use writeline here, instead of UnityEngine.Debug.Log to not include the stacktrace in the editor.log
Console.WriteLine($"[VisualStudio.Editor.{nameof(Cli)}] {message}");
}
internal static string GetInstallationDetails(IVisualStudioInstallation installation)
{
return $"{installation.ToCodeEditorInstallation().Name} Path:{installation.Path}, LanguageVersionSupport:{installation.LatestLanguageVersionSupported} AnalyzersSupport:{installation.SupportsAnalyzers}";
}
internal static void GenerateSolutionWith(VisualStudioEditor vse, string installationPath)
{
if (vse != null && vse.TryGetVisualStudioInstallationForPath(installationPath, lookupDiscoveredInstallations: true, out var vsi))
{
Log($"Using {GetInstallationDetails(vsi)}");
vse.SyncAll();
}
else
{
Log($"No Visual Studio installation found in ${installationPath}!");
}
}
internal static void GenerateSolution()
{
if (CodeEditor.CurrentEditor is VisualStudioEditor vse)
{
Log($"Using default editor settings for Visual Studio installation");
GenerateSolutionWith(vse, CodeEditor.CurrentEditorInstallation);
}
else
{
Log($"Visual Studio is not set as your default editor, looking for installations");
try
{
var installations = Discovery
.GetVisualStudioInstallations()
.Cast<VisualStudioInstallation>()
.OrderByDescending(vsi => !vsi.IsPrerelease)
.ThenBy(vsi => vsi.Version)
.ToArray();
foreach(var vsi in installations)
{
Log($"Detected {GetInstallationDetails(vsi)}");
}
var installation = installations
.FirstOrDefault();
if (installation != null)
{
var current = CodeEditor.CurrentEditorInstallation;
try
{
CodeEditor.SetExternalScriptEditor(installation.Path);
GenerateSolutionWith(CodeEditor.CurrentEditor as VisualStudioEditor, installation.Path);
}
finally
{
CodeEditor.SetExternalScriptEditor(current);
}
} else
{
Log($"No Visual Studio installation found!");
}
}
catch (Exception ex)
{
Log($"Error detecting Visual Studio installations: {ex}");
}
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f7b5530092b3a7646bdc7865f1f6ee94
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.Collections.Generic;
using System.IO;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class Discovery
{
public static IEnumerable<IVisualStudioInstallation> GetVisualStudioInstallations()
{
#if UNITY_EDITOR_WIN
foreach (var installation in VisualStudioForWindowsInstallation.GetVisualStudioInstallations())
yield return installation;
#endif
foreach (var installation in VisualStudioCodeInstallation.GetVisualStudioInstallations())
yield return installation;
}
public static bool TryDiscoverInstallation(string editorPath, out IVisualStudioInstallation installation)
{
try
{
#if UNITY_EDITOR_WIN
if (VisualStudioForWindowsInstallation.TryDiscoverInstallation(editorPath, out installation))
return true;
#endif
if (VisualStudioCodeInstallation.TryDiscoverInstallation(editorPath, out installation))
return true;
}
catch (IOException)
{
installation = null;
}
return false;
}
public static void Initialize()
{
#if UNITY_EDITOR_WIN
VisualStudioForWindowsInstallation.Initialize();
#endif
VisualStudioCodeInstallation.Initialize();
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: abe003ac6fee32e4892100a78f555011
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,106 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.IO;
using UnityEngine;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class FileUtility
{
public const char WinSeparator = '\\';
public const char UnixSeparator = '/';
public static string GetAbsolutePath(string path)
{
#if UNITY_6000_5_OR_NEWER
return UnityEditor.FileUtil
.PathToAbsolutePath(path)
.NormalizePathSeparators();
#else
return Path.GetFullPath(path);
#endif
}
public static string GetPackageAssetFullPath(params string[] components)
{
// Unity has special IO handling of Packages and will resolve those path to the right package location
return GetAbsolutePath(Path.Combine("Packages", "com.unity.ide.visualstudio", Path.Combine(components)));
}
public static string GetAssetFullPath(string asset)
{
var basePath = GetAbsolutePath(Path.Combine(Application.dataPath, ".."));
return GetAbsolutePath(Path.Combine(basePath, NormalizePathSeparators(asset)));
}
public static string NormalizePathSeparators(this string path)
{
if (string.IsNullOrEmpty(path))
return path;
if (Path.DirectorySeparatorChar == WinSeparator)
path = path.Replace(UnixSeparator, WinSeparator);
if (Path.DirectorySeparatorChar == UnixSeparator)
path = path.Replace(WinSeparator, UnixSeparator);
return path.Replace(string.Concat(WinSeparator, WinSeparator), WinSeparator.ToString());
}
public static string NormalizeWindowsToUnix(this string path)
{
if (string.IsNullOrEmpty(path))
return path;
return path.Replace(WinSeparator, UnixSeparator);
}
internal static bool IsFileInProjectRootDirectory(string fileName)
{
var relative = MakeRelativeToProjectPath(fileName);
if (string.IsNullOrEmpty(relative))
return false;
return relative == Path.GetFileName(relative);
}
public static string MakeAbsolutePath(this string path)
{
if (string.IsNullOrEmpty(path)) { return string.Empty; }
return Path.IsPathRooted(path) ? path : GetAbsolutePath(path);
}
// returns null if outside of the project scope
internal static string MakeRelativeToProjectPath(string fileName)
{
var basePath = GetAbsolutePath(Path.Combine(Application.dataPath, ".."));
fileName = NormalizePathSeparators(fileName);
if (!Path.IsPathRooted(fileName))
fileName = Path.Combine(basePath, fileName);
if (!fileName.StartsWith(basePath, StringComparison.OrdinalIgnoreCase))
return null;
return fileName
.Substring(basePath.Length)
.Trim(Path.DirectorySeparatorChar);
}
internal static void SafeDelete(string file)
{
try
{
if (File.Exists(file))
File.Delete(file);
}
catch (IOException)
{
// ignore
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6f1dc05fb6e7d3e4f89ae9ca482735be
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,102 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.IO;
namespace Microsoft.Unity.VisualStudio.Editor
{
public sealed class Image : IDisposable
{
long position;
Stream stream;
Image(Stream stream)
{
this.stream = stream;
this.position = stream.Position;
this.stream.Position = 0;
}
bool Advance(int length)
{
if (stream.Position + length >= stream.Length)
return false;
stream.Seek(length, SeekOrigin.Current);
return true;
}
bool MoveTo(uint position)
{
if (position >= stream.Length)
return false;
stream.Position = position;
return true;
}
void IDisposable.Dispose()
{
stream.Position = position;
}
ushort ReadUInt16()
{
return (ushort)(stream.ReadByte()
| (stream.ReadByte() << 8));
}
uint ReadUInt32()
{
return (uint)(stream.ReadByte()
| (stream.ReadByte() << 8)
| (stream.ReadByte() << 16)
| (stream.ReadByte() << 24));
}
bool IsManagedAssembly()
{
if (stream.Length < 318)
return false;
if (ReadUInt16() != 0x5a4d)
return false;
if (!Advance(58))
return false;
if (!MoveTo(ReadUInt32()))
return false;
if (ReadUInt32() != 0x00004550)
return false;
if (!Advance(20))
return false;
if (!Advance(ReadUInt16() == 0x20b ? 222 : 206))
return false;
return ReadUInt32() != 0;
}
public static bool IsAssembly(string file)
{
if (file == null)
throw new ArgumentNullException("file");
using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read))
return IsAssembly(stream);
}
public static bool IsAssembly(Stream stream)
{
if (stream == null)
throw new ArgumentNullException(nameof(stream));
if (!stream.CanRead)
throw new ArgumentException(nameof(stream));
if (!stream.CanSeek)
throw new ArgumentException(nameof(stream));
using (var image = new Image(stream))
return image.IsManagedAssembly();
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8e6c7ea7c059fb547b6723aaf225900b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,14 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class KnownAssemblies
{
public const string Bridge = "SyntaxTree.VisualStudio.Unity.Bridge";
public const string Messaging = "SyntaxTree.VisualStudio.Unity.Messaging";
public const string UnityVS = "UnityVS.VersionSpecific";
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cbccb6292dce08a489e6e742243154e7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 2f820130c86c28547a0f1a2f4c73155b
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.IO;
using System.Text;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class Deserializer
{
private readonly BinaryReader _reader;
public Deserializer(byte[] buffer)
{
_reader = new BinaryReader(new MemoryStream(buffer));
}
public int ReadInt32()
{
return _reader.ReadInt32();
}
public string ReadString()
{
var length = ReadInt32();
return length > 0
? Encoding.UTF8.GetString(_reader.ReadBytes(length))
: "";
}
public bool CanReadMore()
{
return _reader.BaseStream.Position < _reader.BaseStream.Length;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3eda7a83649158546826efb3ffe6c1e3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,18 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class ExceptionEventArgs
{
public Exception Exception { get; }
public ExceptionEventArgs(Exception exception)
{
Exception = exception;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 917a51fff055ce547b4ad1215321f3da
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,23 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.Globalization;
using System.Net;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class Message
{
public MessageType Type { get; set; }
public string Value { get; set; }
public IPEndPoint Origin { get; set; }
public override string ToString()
{
return string.Format(CultureInfo.InvariantCulture, "<Message type:{0} value:{1}>", Type, Value);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: de1c9ea7b82c9904d9e5fba2ee70a998
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,19 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class MessageEventArgs
{
public Message Message
{
get;
}
public MessageEventArgs(Message message)
{
Message = message;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 275143c81d816ef4286fdc67aabc20c8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,48 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal enum MessageType
{
None = 0,
Ping,
Pong,
Play,
Stop,
Pause,
Unpause,
Build,
Refresh,
Info,
Error,
Warning,
Open,
Opened,
Version,
UpdatePackage,
ProjectPath,
// This message is a technical one for big messages, not intended to be used directly
Tcp,
RunStarted,
RunFinished,
TestStarted,
TestFinished,
TestListRetrieved,
RetrieveTestList,
ExecuteTests,
ShowUsage
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f3edbdc86577af648a23263aa75161e1
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,235 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Net;
using System.Net.Sockets;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class Messager : IDisposable
{
public event EventHandler<MessageEventArgs> ReceiveMessage;
public event EventHandler<ExceptionEventArgs> MessagerException;
private readonly UdpSocket _socket;
private bool _disposed;
#if UNITY_EDITOR_WIN
[System.Runtime.InteropServices.DllImport("kernel32.dll", SetLastError = true)]
private static extern bool SetHandleInformation(IntPtr hObject, HandleFlags dwMask, HandleFlags dwFlags);
[Flags]
private enum HandleFlags: uint
{
None = 0,
Inherit = 1,
ProtectFromClose = 2
}
#endif
protected Messager(int port)
{
_socket = new UdpSocket();
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ExclusiveAddressUse, false);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
#if UNITY_EDITOR_WIN
// Explicitely disable inheritance for our UDP socket handle
// We found that Unity is creating a fork when importing new assets that can clone our socket
SetHandleInformation(_socket.Handle, HandleFlags.Inherit, HandleFlags.None);
#endif
_socket.Bind(IPAddress.Any, port);
BeginReceiveMessage();
}
private void BeginReceiveMessage()
{
var buffer = new byte[UdpSocket.BufferSize];
var any = UdpSocket.Any();
try
{
beginReceive:
if (_disposed)
return;
var result = _socket.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref any, ReceiveMessageCallback, buffer);
if (result.CompletedSynchronously)
goto beginReceive;
}
catch (SocketException se)
{
MessagerException?.Invoke(this, new ExceptionEventArgs(se));
BeginReceiveMessage();
}
catch (ObjectDisposedException)
{
}
}
private void ReceiveMessageCallback(IAsyncResult result)
{
try
{
var endPoint = UdpSocket.Any();
if (_disposed)
return;
_socket.EndReceiveFrom(result, ref endPoint);
var message = DeserializeMessage(UdpSocket.BufferFor(result));
if (message != null)
{
message.Origin = (IPEndPoint)endPoint;
if (IsValidTcpMessage(message, out var port, out var bufferSize))
{
// switch to TCP mode to handle big messages
TcpClient.Queue(message.Origin.Address, port, bufferSize, buffer =>
{
var originalMessage = DeserializeMessage(buffer);
originalMessage.Origin = message.Origin;
ReceiveMessage?.Invoke(this, new MessageEventArgs(originalMessage));
});
}
else
{
ReceiveMessage?.Invoke(this, new MessageEventArgs(message));
}
}
}
catch (ObjectDisposedException)
{
return;
}
catch (Exception e)
{
RaiseMessagerException(e);
}
if (!result.CompletedSynchronously)
BeginReceiveMessage();
}
private static bool IsValidTcpMessage(Message message, out int port, out int bufferSize)
{
port = 0;
bufferSize = 0;
if (message.Value == null)
return false;
if (message.Type != MessageType.Tcp)
return false;
var parts = message.Value.Split(':');
if (parts.Length != 2)
return false;
if (!int.TryParse(parts[0], out port))
return false;
return int.TryParse(parts[1], out bufferSize);
}
private void RaiseMessagerException(Exception e)
{
MessagerException?.Invoke(this, new ExceptionEventArgs(e));
}
private static Message MessageFor(MessageType type, string value)
{
return new Message { Type = type, Value = value };
}
public void SendMessage(IPEndPoint target, MessageType type, string value = "")
{
var message = MessageFor(type, value);
var buffer = SerializeMessage(message);
try
{
if (_disposed)
return;
if (buffer.Length >= UdpSocket.BufferSize)
{
// switch to TCP mode to handle big messages
var port = TcpListener.Queue(buffer);
if (port > 0)
{
// success, replace original message with "switch to tcp" marker + port information + buffer length
message = MessageFor(MessageType.Tcp, string.Concat(port, ':', buffer.Length));
buffer = SerializeMessage(message);
}
}
_socket.BeginSendTo(buffer, 0, Math.Min(buffer.Length, UdpSocket.BufferSize), SocketFlags.None, target, SendMessageCallback, null);
}
catch (SocketException se)
{
MessagerException?.Invoke(this, new ExceptionEventArgs(se));
}
catch (ObjectDisposedException)
{
}
}
private void SendMessageCallback(IAsyncResult result)
{
try
{
if (_disposed)
return;
_socket.EndSendTo(result);
}
catch (SocketException se)
{
MessagerException?.Invoke(this, new ExceptionEventArgs(se));
}
catch (ObjectDisposedException)
{
}
}
private static byte[] SerializeMessage(Message message)
{
var serializer = new Serializer();
serializer.WriteInt32((int)message.Type);
serializer.WriteString(message.Value);
return serializer.Buffer();
}
private static Message DeserializeMessage(byte[] buffer)
{
if (buffer.Length < 4)
return null;
var deserializer = new Deserializer(buffer);
var type = (MessageType)deserializer.ReadInt32();
var value = deserializer.ReadString();
return new Message { Type = type, Value = value };
}
public static Messager BindTo(int port)
{
return new Messager(port);
}
public void Dispose()
{
try
{
_disposed = true;
_socket.Close();
}
catch
{
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5e249ae353801f043a6e4173410c6152
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,43 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.IO;
using System.Text;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class Serializer
{
private readonly MemoryStream _stream;
private readonly BinaryWriter _writer;
public Serializer()
{
_stream = new MemoryStream();
_writer = new BinaryWriter(_stream);
}
public void WriteInt32(int i)
{
_writer.Write(i);
}
public void WriteString(string s)
{
var bytes = Encoding.UTF8.GetBytes(s ?? "");
if (bytes.Length > 0)
{
_writer.Write(bytes.Length);
_writer.Write(bytes);
}
else
_writer.Write(0);
}
public byte[] Buffer()
{
return _stream.ToArray();
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 369c09afe05d2c346af49faef943c773
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,93 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class TcpClient
{
private const int ConnectOrReadTimeoutMilliseconds = 5000;
private class State
{
public System.Net.Sockets.TcpClient TcpClient;
public NetworkStream NetworkStream;
public byte[] Buffer;
public Action<byte[]> OnBufferAvailable;
}
public static void Queue(IPAddress address, int port, int bufferSize, Action<byte[]> onBufferAvailable)
{
var client = new System.Net.Sockets.TcpClient();
var state = new State {OnBufferAvailable = onBufferAvailable, TcpClient = client, Buffer = new byte[bufferSize]};
try
{
ThreadPool.QueueUserWorkItem(_ =>
{
var handle = client.BeginConnect(address, port, OnClientConnected, state);
if (!handle.AsyncWaitHandle.WaitOne(ConnectOrReadTimeoutMilliseconds))
Cleanup(state);
});
}
catch (Exception)
{
Cleanup(state);
}
}
private static void OnClientConnected(IAsyncResult result)
{
var state = (State)result.AsyncState;
try
{
state.TcpClient.EndConnect(result);
state.NetworkStream = state.TcpClient.GetStream();
var handle = state.NetworkStream.BeginRead(state.Buffer, 0, state.Buffer.Length, OnEndRead, state);
if (!handle.AsyncWaitHandle.WaitOne(ConnectOrReadTimeoutMilliseconds))
Cleanup(state);
}
catch (Exception)
{
Cleanup(state);
}
}
private static void OnEndRead(IAsyncResult result)
{
var state = (State)result.AsyncState;
try
{
var count = state.NetworkStream.EndRead(result);
if (count == state.Buffer.Length)
state.OnBufferAvailable?.Invoke(state.Buffer);
}
catch (Exception)
{
// Ignore and cleanup
}
finally
{
Cleanup(state);
}
}
private static void Cleanup(State state)
{
state.NetworkStream?.Dispose();
state.TcpClient?.Close();
state.NetworkStream = null;
state.TcpClient = null;
state.Buffer = null;
state.OnBufferAvailable = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f6674c38820d12a49ac116d416521d85
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,82 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Net;
using System.Threading;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class TcpListener
{
private const int ListenTimeoutMilliseconds = 5000;
private class State
{
public System.Net.Sockets.TcpListener TcpListener;
public byte[] Buffer;
}
public static int Queue(byte[] buffer)
{
var tcpListener = new System.Net.Sockets.TcpListener(IPAddress.Any, 0);
var state = new State {Buffer = buffer, TcpListener = tcpListener};
try
{
tcpListener.Start();
int port = ((IPEndPoint)tcpListener.LocalEndpoint).Port;
ThreadPool.QueueUserWorkItem(_ =>
{
bool listening = true;
while (listening)
{
var handle = tcpListener.BeginAcceptTcpClient(OnIncomingConnection, state);
listening = handle.AsyncWaitHandle.WaitOne(ListenTimeoutMilliseconds);
}
Cleanup(state);
});
return port;
}
catch (Exception)
{
Cleanup(state);
return -1;
}
}
private static void OnIncomingConnection(IAsyncResult result)
{
var state = (State)result.AsyncState;
try
{
using (var client = state.TcpListener.EndAcceptTcpClient(result))
{
using (var stream = client.GetStream())
{
stream.Write(state.Buffer, 0, state.Buffer.Length);
}
}
}
catch (Exception)
{
// Ignore and cleanup
}
}
private static void Cleanup(State state)
{
state.TcpListener?.Stop();
state.TcpListener = null;
state.Buffer = null;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ded625cf0d03fa94c9f939fd13ced18d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,54 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Net;
using System.Net.Sockets;
namespace Microsoft.Unity.VisualStudio.Editor.Messaging
{
internal class UdpSocket : Socket
{
// Maximum UDP payload is 65507 bytes.
// TCP mode will be used when the payload is bigger than this BufferSize
public const int BufferSize = 1024 * 8;
internal UdpSocket()
: base(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp)
{
SetIOControl();
}
public void Bind(IPAddress address, int port = 0)
{
Bind(new IPEndPoint(address ?? IPAddress.Any, port));
}
private void SetIOControl()
{
#if UNITY_EDITOR_WIN
try
{
const int SIO_UDP_CONNRESET = -1744830452;
IOControl(SIO_UDP_CONNRESET, new byte[] { 0 }, new byte[0]);
}
catch
{
// fallback
}
#endif
}
public static byte[] BufferFor(IAsyncResult result)
{
return (byte[])result.AsyncState;
}
public static EndPoint Any()
{
return new IPEndPoint(IPAddress.Any, 0);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 38cb3a4a17d2cfd41926da95ce675934
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,112 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class ProcessRunnerResult
{
public bool Success { get; set; }
public string Output { get; set; }
public string Error { get; set; }
}
internal static class ProcessRunner
{
public const int DefaultTimeoutInMilliseconds = 300000;
public static ProcessStartInfo ProcessStartInfoFor(string filename, string arguments, bool redirect = true, bool shell = false)
{
return new ProcessStartInfo
{
UseShellExecute = shell,
CreateNoWindow = true,
RedirectStandardOutput = redirect,
RedirectStandardError = redirect,
FileName = filename,
Arguments = arguments
};
}
public static void Start(string filename, string arguments)
{
Start(ProcessStartInfoFor(filename, arguments, false));
}
public static void Start(ProcessStartInfo processStartInfo)
{
var process = new Process { StartInfo = processStartInfo };
using (process)
{
process.Start();
}
}
public static ProcessRunnerResult StartAndWaitForExit(string filename, string arguments, int timeoutms = DefaultTimeoutInMilliseconds, Action<string> onOutputReceived = null)
{
return StartAndWaitForExit(ProcessStartInfoFor(filename, arguments), timeoutms, onOutputReceived);
}
public static ProcessRunnerResult StartAndWaitForExit(ProcessStartInfo processStartInfo, int timeoutms = DefaultTimeoutInMilliseconds, Action<string> onOutputReceived = null)
{
var process = new Process { StartInfo = processStartInfo };
using (process)
{
var sbOutput = new StringBuilder();
var sbError = new StringBuilder();
var outputSource = new TaskCompletionSource<bool>();
var errorSource = new TaskCompletionSource<bool>();
process.OutputDataReceived += (_, e) =>
{
Append(sbOutput, e.Data, outputSource);
if (onOutputReceived != null && e.Data != null)
onOutputReceived(e.Data);
};
process.ErrorDataReceived += (_, e) => Append(sbError, e.Data, errorSource);
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
var run = Task.Run(() => process.WaitForExit(timeoutms));
var processTask = Task.WhenAll(run, outputSource.Task, errorSource.Task);
if (Task.WhenAny(Task.Delay(timeoutms), processTask).Result == processTask && run.Result)
return new ProcessRunnerResult {Success = true, Error = sbError.ToString(), Output = sbOutput.ToString()};
try
{
process.Kill();
}
catch
{
/* ignore */
}
return new ProcessRunnerResult {Success = false, Error = sbError.ToString(), Output = sbOutput.ToString()};
}
}
private static void Append(StringBuilder sb, string data, TaskCompletionSource<bool> taskSource)
{
if (data == null)
{
taskSource.SetResult(true);
return;
}
sb?.Append(data);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 957a5f2d2660a894d926660de2a9d577
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 8beeeeebc0857854d8b4e2c2895dd7a9
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,220 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEditor.PackageManager;
namespace Microsoft.Unity.VisualStudio.Editor
{
public interface IAssemblyNameProvider
{
string[] ProjectSupportedExtensions { get; }
string ProjectGenerationRootNamespace { get; }
ProjectGenerationFlag ProjectGenerationFlag { get; }
string GetAssemblyNameFromScriptPath(string path);
string GetAssemblyName(string assemblyOutputPath, string assemblyName);
bool IsInternalizedPackagePath(string path);
IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
IEnumerable<string> GetAllAssetPaths();
UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
void ToggleProjectGeneration(ProjectGenerationFlag preference);
}
public class AssemblyNameProvider : IAssemblyNameProvider
{
private readonly Dictionary<string, UnityEditor.PackageManager.PackageInfo> m_PackageInfoCache = new Dictionary<string, UnityEditor.PackageManager.PackageInfo>();
ProjectGenerationFlag m_ProjectGenerationFlag = (ProjectGenerationFlag)EditorPrefs.GetInt(
"unity_project_generation_flag",
(int)(ProjectGenerationFlag.Local | ProjectGenerationFlag.Embedded));
public string[] ProjectSupportedExtensions => EditorSettings.projectGenerationUserExtensions;
public string ProjectGenerationRootNamespace => EditorSettings.projectGenerationRootNamespace;
public ProjectGenerationFlag ProjectGenerationFlag
{
get { return ProjectGenerationFlagImpl; }
private set { ProjectGenerationFlagImpl = value;}
}
internal virtual ProjectGenerationFlag ProjectGenerationFlagImpl
{
get => m_ProjectGenerationFlag;
private set
{
EditorPrefs.SetInt("unity_project_generation_flag", (int)value);
m_ProjectGenerationFlag = value;
}
}
public string GetAssemblyNameFromScriptPath(string path)
{
return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
}
internal static readonly string AssemblyOutput = @"Temp\bin\Debug\".NormalizePathSeparators();
internal static readonly string PlayerAssemblyOutput = @"Temp\bin\Debug\Player\".NormalizePathSeparators();
public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
{
IEnumerable<Assembly> assemblies = GetAssembliesByType(AssembliesType.Editor, shouldFileBePartOfSolution, AssemblyOutput);
if (!ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.PlayerAssemblies))
{
return assemblies;
}
var playerAssemblies = GetAssembliesByType(AssembliesType.Player, shouldFileBePartOfSolution, PlayerAssemblyOutput);
return assemblies.Concat(playerAssemblies);
}
private static IEnumerable<Assembly> GetAssembliesByType(AssembliesType type, Func<string, bool> shouldFileBePartOfSolution, string outputPath)
{
foreach (var assembly in CompilationPipeline.GetAssemblies(type))
{
if (assembly.sourceFiles.Any(shouldFileBePartOfSolution))
{
yield return new Assembly(
assembly.name,
outputPath,
assembly.sourceFiles,
assembly.defines,
assembly.assemblyReferences,
assembly.compiledAssemblyReferences,
assembly.flags,
assembly.compilerOptions
#if UNITY_2020_2_OR_NEWER
, assembly.rootNamespace
#endif
);
}
}
}
public string GetCompileOutputPath(string assemblyName)
{
// We need to keep this one for API surface check (AssemblyNameProvider is public), but not used anymore
throw new NotImplementedException();
}
public IEnumerable<string> GetAllAssetPaths()
{
return AssetDatabase.GetAllAssetPaths();
}
private static string ResolvePotentialParentPackageAssetPath(string assetPath)
{
const string packagesPrefix = "packages/";
if (!assetPath.StartsWith(packagesPrefix, StringComparison.OrdinalIgnoreCase))
{
return null;
}
var followupSeparator = assetPath.IndexOf('/', packagesPrefix.Length);
if (followupSeparator == -1)
{
return assetPath.ToLowerInvariant();
}
return assetPath.Substring(0, followupSeparator).ToLowerInvariant();
}
public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
{
var parentPackageAssetPath = ResolvePotentialParentPackageAssetPath(assetPath);
if (parentPackageAssetPath == null)
{
return null;
}
if (m_PackageInfoCache.TryGetValue(parentPackageAssetPath, out var cachedPackageInfo))
{
return cachedPackageInfo;
}
var result = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(parentPackageAssetPath);
m_PackageInfoCache[parentPackageAssetPath] = result;
return result;
}
public bool IsInternalizedPackagePath(string path)
{
if (string.IsNullOrEmpty(path.Trim()))
{
return false;
}
var packageInfo = FindForAssetPath(path);
if (packageInfo == null)
{
return false;
}
var packageSource = packageInfo.source;
switch (packageSource)
{
case PackageSource.Embedded:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Embedded);
case PackageSource.Registry:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Registry);
case PackageSource.BuiltIn:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.BuiltIn);
case PackageSource.Unknown:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Unknown);
case PackageSource.Local:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Local);
case PackageSource.Git:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Git);
case PackageSource.LocalTarball:
return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.LocalTarBall);
}
return false;
}
public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
{
return CompilationPipeline.ParseResponseFile(
responseFilePath,
projectDirectory,
systemReferenceDirectories
);
}
public void ToggleProjectGeneration(ProjectGenerationFlag preference)
{
if (ProjectGenerationFlag.HasFlag(preference))
{
ProjectGenerationFlag ^= preference;
}
else
{
ProjectGenerationFlag |= preference;
}
}
internal void ResetPackageInfoCache()
{
m_PackageInfoCache.Clear();
}
public void ResetProjectGenerationFlag()
{
ProjectGenerationFlag = ProjectGenerationFlag.None;
}
public string GetAssemblyName(string assemblyOutputPath, string assemblyName)
{
if (assemblyOutputPath == PlayerAssemblyOutput)
return assemblyName + ".Player";
return assemblyName;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 57537f08f8e923f488e4aadabb831c9b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,36 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.IO;
using System.Text;
namespace Microsoft.Unity.VisualStudio.Editor
{
public interface IFileIO
{
bool Exists(string fileName);
string ReadAllText(string fileName);
void WriteAllText(string fileName, string content);
}
class FileIOProvider : IFileIO
{
public bool Exists(string fileName)
{
return File.Exists(fileName);
}
public string ReadAllText(string fileName)
{
return File.ReadAllText(fileName);
}
public void WriteAllText(string fileName, string content)
{
File.WriteAllText(fileName, content, Encoding.UTF8);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ec80b1fb8938b3b4ab442d10390c5315
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,26 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
namespace Microsoft.Unity.VisualStudio.Editor
{
public interface IGUIDGenerator
{
string ProjectGuid(string projectName, string assemblyName);
string SolutionGuid(string projectName, ScriptingLanguage scriptingLanguage);
}
class GUIDProvider : IGUIDGenerator
{
public string ProjectGuid(string projectName, string assemblyName)
{
return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
}
public string SolutionGuid(string projectName, ScriptingLanguage scriptingLanguage)
{
return SolutionGuidGenerator.GuidForSolution(projectName, scriptingLanguage);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7652904b1008e324fb7cfb952ea87656
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal enum GeneratorStyle
{
SDK = 1,
Legacy = 2,
}
internal static class GeneratorFactory
{
private static readonly SdkStyleProjectGeneration _sdkStyleProjectGeneration = new SdkStyleProjectGeneration();
private static readonly LegacyStyleProjectGeneration _legacyStyleProjectGeneration = new LegacyStyleProjectGeneration();
public static IGenerator GetInstance(GeneratorStyle style)
{
var forceStyleString = OnSelectingCSProjectStyle();
if (forceStyleString != null && Enum.TryParse<GeneratorStyle>(forceStyleString, out var forceStyle))
style = forceStyle;
if (style == GeneratorStyle.SDK)
return _sdkStyleProjectGeneration;
if (style == GeneratorStyle.Legacy)
return _legacyStyleProjectGeneration;
throw new ArgumentException("Unknown generator style");
}
private static string OnSelectingCSProjectStyle()
{
foreach (var method in TypeCacheHelper.GetPostProcessorCallbacks(nameof(OnSelectingCSProjectStyle)))
{
object retValue = method.Invoke(null, Array.Empty<object>());
if (method.ReturnType != typeof(string))
continue;
return retValue as string;
}
return null;
}
}
}
@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: c94f13e05ef0a7a49bdd39f197f39e5e
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,129 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.Collections.Generic;
using System.Text;
using UnityEditor.Compilation;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class LegacyStyleProjectGeneration : ProjectGeneration
{
internal override GeneratorStyle Style => GeneratorStyle.Legacy;
public LegacyStyleProjectGeneration(string tempDirectory, IAssemblyNameProvider assemblyNameProvider, IFileIO fileIoProvider, IGUIDGenerator guidGenerator) : base(tempDirectory, assemblyNameProvider, fileIoProvider, guidGenerator)
{
}
public LegacyStyleProjectGeneration(string tempDirectory) : base(tempDirectory)
{
}
public LegacyStyleProjectGeneration()
{
}
internal override void GetProjectHeader(ProjectProperties properties, out StringBuilder headerBuilder)
{
headerBuilder = new StringBuilder();
//Header
headerBuilder.Append(@"<?xml version=""1.0"" encoding=""utf-8""?>").Append(k_WindowsNewline);
headerBuilder.Append($@"<Project ToolsVersion=""4.0"" DefaultTargets=""Build"" xmlns=""{MSBuildNamespaceUri}"">").Append(k_WindowsNewline);
headerBuilder.Append(@" <!-- Generated file, do not modify, your changes will be overwritten (use AssetPostprocessor.OnGeneratedCSProject) -->").Append(k_WindowsNewline);
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <LangVersion>").Append(properties.LangVersion).Append(@"</LangVersion>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <Configuration Condition="" '$(Configuration)' == '' "">Debug</Configuration>").Append(k_WindowsNewline);
headerBuilder.Append(@" <Platform Condition="" '$(Platform)' == '' "">AnyCPU</Platform>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ProductVersion>10.0.20506</ProductVersion>").Append(k_WindowsNewline);
headerBuilder.Append(@" <SchemaVersion>2.0</SchemaVersion>").Append(k_WindowsNewline);
headerBuilder.Append(@" <RootNamespace>").Append(properties.RootNamespace).Append(@"</RootNamespace>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ProjectGuid>{").Append(properties.ProjectGuid).Append(@"}</ProjectGuid>").Append(k_WindowsNewline);
headerBuilder.Append(@" <OutputType>Library</OutputType>").Append(k_WindowsNewline);
headerBuilder.Append(@" <AppDesignerFolder>Properties</AppDesignerFolder>").Append(k_WindowsNewline);
headerBuilder.Append(@" <AssemblyName>").Append(properties.AssemblyName).Append(@"</AssemblyName>").Append(k_WindowsNewline);
// In the end, given we use NoConfig/NoStdLib (see below), hardcoding the target framework version with the legacy format will have no impact, even when targeting netstandard/net48 from Unity.
// And VSTU/Unity Game workload has a dependency towards net471 reference assemblies, so IDE will not complain that this specific SDK is not available.
// Unity already selected proper API surface through referenced DLLs for us.
headerBuilder.Append(@" <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>").Append(k_WindowsNewline);
headerBuilder.Append(@" <FileAlignment>512</FileAlignment>").Append(k_WindowsNewline);
headerBuilder.Append(@" <BaseDirectory>.</BaseDirectory>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
GetProjectHeaderProperties(properties, headerBuilder);
GetProjectHeaderConfigurations(properties, headerBuilder);
// Explicit references
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <NoConfig>true</NoConfig>").Append(k_WindowsNewline);
headerBuilder.Append(@" <NoStdLib>true</NoStdLib>").Append(k_WindowsNewline);
headerBuilder.Append(@" <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ImplicitlyExpandNETStandardFacades>false</ImplicitlyExpandNETStandardFacades>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ImplicitlyExpandDesignTimeFacades>false</ImplicitlyExpandDesignTimeFacades>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
GetProjectHeaderVstuFlavoring(properties, headerBuilder);
GetProjectHeaderAnalyzers(properties, headerBuilder);
}
internal static void GetProjectHeaderConfigurations(ProjectProperties properties, StringBuilder headerBuilder)
{
headerBuilder.Append(@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "">").Append(k_WindowsNewline);
headerBuilder.Append(@" <DebugSymbols>true</DebugSymbols>").Append(k_WindowsNewline);
headerBuilder.Append(@" <DebugType>full</DebugType>").Append(k_WindowsNewline);
headerBuilder.Append(@" <Optimize>false</Optimize>").Append(k_WindowsNewline);
headerBuilder.Append(@" <OutputPath>").Append(properties.OutputPath).Append(@"</OutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ErrorReport>prompt</ErrorReport>").Append(k_WindowsNewline);
headerBuilder.Append(@" <WarningLevel>4</WarningLevel>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <PropertyGroup Condition="" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "">").Append(k_WindowsNewline);
headerBuilder.Append(@" <DebugType>pdbonly</DebugType>").Append(k_WindowsNewline);
headerBuilder.Append(@" <Optimize>true</Optimize>").Append(k_WindowsNewline);
headerBuilder.Append($" <OutputPath>{@"Temp\bin\Release\".NormalizePathSeparators()}</OutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" <ErrorReport>prompt</ErrorReport>").Append(k_WindowsNewline);
headerBuilder.Append(@" <WarningLevel>4</WarningLevel>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
}
internal override void AppendProjectReference(Assembly assembly, Assembly reference, StringBuilder projectBuilder)
{
// If the current assembly is a Player project, we want to project-reference the corresponding Player project
var referenceName = m_AssemblyNameProvider.GetAssemblyName(assembly.outputPath, reference.name);
projectBuilder.Append(@" <ProjectReference Include=""").Append(referenceName).Append(GetProjectExtension()).Append(@""">").Append(k_WindowsNewline);
projectBuilder.Append(" <Project>{").Append(ProjectGuid(referenceName)).Append("}</Project>").Append(k_WindowsNewline);
projectBuilder.Append(" <Name>").Append(referenceName).Append("</Name>").Append(k_WindowsNewline);
projectBuilder.Append(" </ProjectReference>").Append(k_WindowsNewline);
}
internal override void GetProjectFooter(StringBuilder footerBuilder)
{
footerBuilder.Append(string.Join(k_WindowsNewline,
$" <Import Project=\"{@"$(MSBuildToolsPath)\Microsoft.CSharp.targets".NormalizePathSeparators()}\" />",
@" <Target Name=""GenerateTargetFrameworkMonikerAttribute"" />",
@" <!-- 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>",
@""));
}
internal override void SyncSolution(IEnumerable<Assembly> assemblies)
{
// make sure we can't have sln and slnx solutions at the same time.
FileUtility.SafeDelete(base.SolutionFileImpl() + 'x');
base.SyncSolution(assemblies);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3070b6395b0f5f04faaab13164c6256d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 9f3705b95d031e84c82f140d8e980867
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,23 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
namespace Microsoft.Unity.VisualStudio.Editor
{
[Flags]
public enum ProjectGenerationFlag
{
None = 0,
Embedded = 1,
Local = 2,
Registry = 4,
Git = 8,
BuiltIn = 16,
Unknown = 32,
PlayerAssemblies = 64,
LocalTarBall = 128,
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 555fcccd6b79a864f83e7a319daa1c3e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,30 @@
using System;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class ProjectProperties
{
public string ProjectGuid { get; set; } = string.Empty;
public string LangVersion { get; set; } = "latest";
public string AssemblyName { get; set; } = string.Empty;
public string RootNamespace { get; set; } = string.Empty;
public string OutputPath { get; set; } = string.Empty;
// Analyzers
public string[] Analyzers { get; set; } = Array.Empty<string>();
public string RulesetPath { get; set; } = string.Empty;
public string AnalyzerConfigPath { get; set; } = string.Empty;
// Source generators
public string[] AdditionalFilePaths { get; set; } = Array.Empty<string>();
// RSP alterable
public string[] Defines { get; set; } = Array.Empty<string>();
public bool Unsafe { get; set; } = false;
// VSTU Flavouring
public string FlavoringProjectType { get; set; } = string.Empty;
public string FlavoringBuildTarget { get; set; } = string.Empty;
public string FlavoringUnityVersion { get; set; } = string.Empty;
public string FlavoringPackageVersion { get; set; } = string.Empty;
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: fa7011e2ea1ff024083fea2179f3df08
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,157 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEditor.Compilation;
using UnityEngine;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class SdkStyleProjectGeneration : ProjectGeneration
{
internal override GeneratorStyle Style => GeneratorStyle.SDK;
internal class SdkStyleAssemblyNameProvider : AssemblyNameProvider
{
// disable PlayerGeneration with SdkStyle projects
internal override ProjectGenerationFlag ProjectGenerationFlagImpl => base.ProjectGenerationFlagImpl & ~ProjectGenerationFlag.PlayerAssemblies;
}
public SdkStyleProjectGeneration() : base(
Directory.GetParent(Application.dataPath)?.FullName,
new SdkStyleAssemblyNameProvider(),
new FileIOProvider(),
new GUIDProvider())
{
}
internal static readonly string[] SupportedCapabilities = new string[]
{
"Unity", // Allows to load the VSTU package and activate Unity specific features
"EnableOnDemandExcludedFolderLoading", // Lazy-load excluded folders in VS (useful for huge projects with many side assets)
};
internal static readonly string[] UnsupportedCapabilities = new string[]
{
"LaunchProfiles",
"SharedProjectReferences",
"ReferenceManagerSharedProjects",
"ReferenceManagerProjects",
"COMReferences",
"ReferenceManagerCOM",
"AssemblyReferences",
"ReferenceManagerAssemblies",
};
internal override void GetProjectHeader(ProjectProperties properties, out StringBuilder headerBuilder)
{
headerBuilder = new StringBuilder();
headerBuilder.Append(@"<Project>").Append(k_WindowsNewline);
headerBuilder.Append(@" <!-- Generated file, do not modify, your changes will be overwritten (use AssetPostprocessor.OnGeneratedCSProject) -->").Append(k_WindowsNewline);
// Prevent circular dependency issues see https://github.com/microsoft/vscode-dotnettools/issues/401
// We need a dedicated subfolder for each project in obj, otherwise depending on the build order, nuget cache files could be overwritten
// We need to do this before common.props, otherwise we'll have a MSB3539 The value of the property "BaseIntermediateOutputPath" was modified after it was used by MSBuild
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append($" <BaseIntermediateOutputPath>{@"Temp\obj\$(MSBuildProjectName)".NormalizePathSeparators()}</BaseIntermediateOutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" <IntermediateOutputPath>$(BaseIntermediateOutputPath)</IntermediateOutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" <UseCommonOutputDirectory>true</UseCommonOutputDirectory>").Append(k_WindowsNewline);
headerBuilder.Append($" <OutputPath>").Append(properties.OutputPath.NormalizePathSeparators()).Append(@"</OutputPath>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
// Supported capabilities
GetCapabilityBlock(headerBuilder, "Sdk.props", "Include", SupportedCapabilities);
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <GenerateAssemblyInfo>false</GenerateAssemblyInfo>").Append(k_WindowsNewline);
headerBuilder.Append(@" <EnableDefaultItems>false</EnableDefaultItems>").Append(k_WindowsNewline);
headerBuilder.Append(@" <LangVersion>").Append(properties.LangVersion).Append(@"</LangVersion>").Append(k_WindowsNewline);
headerBuilder.Append(@" <RootNamespace>").Append(properties.RootNamespace).Append(@"</RootNamespace>").Append(k_WindowsNewline);
headerBuilder.Append(@" <OutputType>Library</OutputType>").Append(k_WindowsNewline);
headerBuilder.Append(@" <AssemblyName>").Append(properties.AssemblyName).Append(@"</AssemblyName>").Append(k_WindowsNewline);
// In the end, given we use NoConfig/NoStdLib (see below), hardcoding the target framework version will have no impact, even when targeting netstandard/net48 from Unity.
// But with SDK style we use netstandard2.1 (net471 for legacy), so 3rd party tools will not fail to work when .NETFW reference assemblies are not installed.
// Unity already selected proper API surface through referenced DLLs for us.
headerBuilder.Append(@" <TargetFramework>netstandard2.1</TargetFramework>").Append(k_WindowsNewline);
headerBuilder.Append(@" <BaseDirectory>.</BaseDirectory>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
GetProjectHeaderProperties(properties, headerBuilder);
// Explicit references
headerBuilder.Append(@" <PropertyGroup>").Append(k_WindowsNewline);
headerBuilder.Append(@" <NoStandardLibraries>true</NoStandardLibraries>").Append(k_WindowsNewline);
headerBuilder.Append(@" <NoStdLib>true</NoStdLib>").Append(k_WindowsNewline);
headerBuilder.Append(@" <NoConfig>true</NoConfig>").Append(k_WindowsNewline);
headerBuilder.Append(@" <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>").Append(k_WindowsNewline);
headerBuilder.Append(@" <MSBuildWarningsAsMessages>MSB3277</MSBuildWarningsAsMessages>").Append(k_WindowsNewline);
headerBuilder.Append(@" </PropertyGroup>").Append(k_WindowsNewline);
GetProjectHeaderVstuFlavoring(properties, headerBuilder, false);
GetProjectHeaderAnalyzers(properties, headerBuilder);
}
internal override void AppendProjectReference(Assembly assembly, Assembly reference, StringBuilder projectBuilder)
{
// If the current assembly is a Player project, we want to project-reference the corresponding Player project
var referenceName = m_AssemblyNameProvider.GetAssemblyName(assembly.outputPath, reference.name);
projectBuilder.Append(@" <ProjectReference Include=""").Append(referenceName).Append(GetProjectExtension()).Append(@""" />").Append(k_WindowsNewline);
}
internal override void GetProjectFooter(StringBuilder footerBuilder)
{
// Unsupported capabilities
GetCapabilityBlock(footerBuilder, "Sdk.targets", "Remove", UnsupportedCapabilities);
footerBuilder.Append("</Project>").Append(k_WindowsNewline);
}
internal static void GetCapabilityBlock(StringBuilder footerBuilder, string import, string attribute, string[] capabilities)
{
footerBuilder.Append($@" <Import Project=""{import}"" Sdk=""Microsoft.NET.Sdk"" />").Append(k_WindowsNewline);
footerBuilder.Append(@" <ItemGroup>").Append(k_WindowsNewline);
foreach (var capability in capabilities)
{
footerBuilder.Append($@" <ProjectCapability {attribute}=""{capability}"" />").Append(k_WindowsNewline);
}
footerBuilder.Append(@" </ItemGroup>").Append(k_WindowsNewline);
}
internal override string SolutionFileImpl()
{
return base.SolutionFileImpl() + "x";
}
internal override string SolutionText(IEnumerable<Assembly> assemblies, Solution previousSolution = null)
{
var projects = GetSolutionProjects(assemblies, previousSolution);
var content = new StringBuilder();
content.Append("<Solution>").Append(k_WindowsNewline);
foreach (var project in projects)
{
content.Append(" ").Append("<Project Path=\"").Append(project.FileName).Append("\" />").Append(k_WindowsNewline);
}
content.Append("</Solution>").Append(k_WindowsNewline);
return content.ToString();
}
internal override void SyncSolution(IEnumerable<Assembly> assemblies)
{
// make sure we can't have sln and slnx solutions at the same time.
FileUtility.SafeDelete(base.SolutionFileImpl());
base.SyncSolution(assemblies);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e8aed47cdce10fd4cae32fefa2c34f8f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,27 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Unity Technologies.
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using SR = System.Reflection;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
namespace Microsoft.Unity.VisualStudio.Editor {
internal class TypeCacheHelper
{
internal static IEnumerable<SR.MethodInfo> GetPostProcessorCallbacks(string name)
{
return TypeCache
.GetTypesDerivedFrom<AssetPostprocessor>()
.Where(t => t.Assembly.GetName().Name != KnownAssemblies.Bridge) // never call into the bridge if loaded with the package
.Select(t => t.GetMethod(name, SR.BindingFlags.Public | SR.BindingFlags.NonPublic | SR.BindingFlags.Static))
.Where(m => m != null);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: eeb21ffd7b0188542b348935f4b04fe8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ed8e7c93c781e48df93d063a3c0d2972
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,12 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class Solution
{
public SolutionProjectEntry[] Projects { get; set; }
public SolutionProperties[] Properties { get; set; }
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: af4c2c762e1d8e949a6bc458973df6e7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,118 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml.Linq;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class SolutionParser
{
// Compared to the bridge implementation, we are not returning "{" "}" from Guids
private static readonly Regex ProjectDeclaration = new Regex(@"Project\(\""{(?<projectFactoryGuid>.*?)}\""\)\s+=\s+\""(?<name>.*?)\"",\s+\""(?<fileName>.*?)\"",\s+\""{(?<projectGuid>.*?)}\""(?<metadata>.*?)\bEndProject\b", RegexOptions.Singleline | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
private static readonly Regex PropertiesDeclaration = new Regex(@"GlobalSection\((?<name>([\w]+Properties|NestedProjects))\)\s+=\s+(?<type>(?:post|pre)Solution)(?<entries>.*?)EndGlobalSection", RegexOptions.Singleline | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
private static readonly Regex PropertiesEntryDeclaration = new Regex(@"^\s*(?<key>.*?)=(?<value>.*?)$", RegexOptions.Multiline | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
public static Solution ParseSolutionFile(string filename, IFileIO fileIO)
{
var extension = Path.GetExtension(filename).ToLower();
if (extension == ".sln")
{
return ParseSolutionContent(fileIO.ReadAllText(filename));
}
if (extension == ".slnx")
{
return ParseSolutionXmlContent(fileIO.ReadAllText(filename));
}
throw new NotSupportedException();
}
private static Solution ParseSolutionContent(string content)
{
return new Solution
{
Projects = ParseSolutionProjects(content),
Properties = ParseSolutionProperties(content)
};
}
private static SolutionProjectEntry[] ParseSolutionProjects(string content)
{
var projects = new List<SolutionProjectEntry>();
var mc = ProjectDeclaration.Matches(content);
foreach (Match match in mc)
{
projects.Add(new SolutionProjectEntry
{
ProjectFactoryGuid = match.Groups["projectFactoryGuid"].Value,
Name = match.Groups["name"].Value,
FileName = match.Groups["fileName"].Value,
ProjectGuid = match.Groups["projectGuid"].Value,
Metadata = match.Groups["metadata"].Value
});
}
return projects.ToArray();
}
private static SolutionProperties[] ParseSolutionProperties(string content)
{
var properties = new List<SolutionProperties>();
var mc = PropertiesDeclaration.Matches(content);
foreach (Match match in mc)
{
var sp = new SolutionProperties
{
Entries = new List<KeyValuePair<string, string>>(),
Name = match.Groups["name"].Value,
Type = match.Groups["type"].Value
};
var entries = match.Groups["entries"].Value;
var mec = PropertiesEntryDeclaration.Matches(entries);
foreach (Match entry in mec)
{
var key = entry.Groups["key"].Value.Trim();
var value = entry.Groups["value"].Value.Trim();
sp.Entries.Add(new KeyValuePair<string, string>(key, value));
}
properties.Add(sp);
}
return properties.ToArray();
}
private static Solution ParseSolutionXmlContent(string content)
{
return new Solution
{
Projects = ParseSolutionXmlProjects(content),
Properties = Array.Empty<SolutionProperties>(),
};
}
private static SolutionProjectEntry[] ParseSolutionXmlProjects(string content)
{
var document = XDocument.Parse(content);
var projects = new List<SolutionProjectEntry>();
foreach (var project in document.Descendants("Project"))
{
projects.Add(new SolutionProjectEntry
{
FileName = project.Attribute("Path")?.Value,
});
}
return projects.ToArray();
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: fbbb1ee655846b043baf6c3502b5ce49
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,22 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class SolutionProjectEntry
{
public string ProjectFactoryGuid { get; set; }
public string Name { get; set; }
public string FileName { get; set; }
public string ProjectGuid { get; set; }
public string Metadata { get; set; }
public bool IsSolutionFolderProjectFactory()
{
return ProjectFactoryGuid != null && ProjectFactoryGuid.Equals("2150E333-8FDC-42A3-9474-1A3956D46DE8", StringComparison.OrdinalIgnoreCase);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5c1b8a755d2c97640bbb207c43f4cf61
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,15 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System.Collections.Generic;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal class SolutionProperties
{
public string Name { get; set; }
public IList<KeyValuePair<string, string>> Entries { get; set; }
public string Type { get; set; }
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 829d4d6bc39fd1044ba4c5fc2a9c911f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,30 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
using System;
using System.IO;
namespace Microsoft.Unity.VisualStudio.Editor
{
internal static class Symbols
{
public static bool IsPortableSymbolFile(string pdbFile)
{
try
{
using (var stream = File.OpenRead(pdbFile))
{
return stream.ReadByte() == 'B'
&& stream.ReadByte() == 'S'
&& stream.ReadByte() == 'J'
&& stream.ReadByte() == 'B';
}
}
catch (Exception)
{
return false;
}
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b9308b762484008498bb5cd1886aa491
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 7f9f1d015d7a8ba46b7d71acfcda3ae7
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,46 @@
using System;
using UnityEditor.TestTools.TestRunner.Api;
#if UNITY_6000_5_OR_NEWER
using UnityEngine;
#endif
namespace Microsoft.Unity.VisualStudio.Editor.Testing
{
[Serializable]
internal class TestAdaptorContainer
{
public TestAdaptor[] TestAdaptors;
}
[Serializable]
internal class TestAdaptor
{
public string Id;
public string Name;
public string FullName;
public string Type;
public string Method;
public string Assembly;
public int Parent;
public TestAdaptor(ITestAdaptor testAdaptor, int parent)
{
Id = testAdaptor.Id;
Name = testAdaptor.Name;
FullName = testAdaptor.FullName;
Type = testAdaptor.TypeInfo?.FullName;
Method = testAdaptor.Method?.Name;
#if UNITY_6000_5_OR_NEWER
Assembly = testAdaptor.TypeInfo?.Assembly?.GetLoadedAssemblyPath();
#else
Assembly = testAdaptor.TypeInfo?.Assembly?.Location;
#endif
Parent = parent;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b73b3de0d473d4a1c887ab31f69b1a8d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,60 @@
using System;
using UnityEditor.TestTools.TestRunner.Api;
namespace Microsoft.Unity.VisualStudio.Editor.Testing
{
[Serializable]
internal class TestResultAdaptorContainer
{
public TestResultAdaptor[] TestResultAdaptors;
}
[Serializable]
internal class TestResultAdaptor
{
public string Name;
public string FullName;
public int PassCount;
public int FailCount;
public int InconclusiveCount;
public int SkipCount;
public string ResultState;
public string StackTrace;
public TestStatusAdaptor TestStatus;
public int Parent;
public TestResultAdaptor(ITestResultAdaptor testResultAdaptor, int parent)
{
Name = testResultAdaptor.Name;
FullName = testResultAdaptor.FullName;
PassCount = testResultAdaptor.PassCount;
FailCount = testResultAdaptor.FailCount;
InconclusiveCount = testResultAdaptor.InconclusiveCount;
SkipCount = testResultAdaptor.SkipCount;
switch (testResultAdaptor.TestStatus)
{
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Passed:
TestStatus = TestStatusAdaptor.Passed;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Skipped:
TestStatus = TestStatusAdaptor.Skipped;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Inconclusive:
TestStatus = TestStatusAdaptor.Inconclusive;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Failed:
TestStatus = TestStatusAdaptor.Failed;
break;
}
Parent = parent;
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f47f2d030bc1d415a8d15a51dbcc39a2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,55 @@
using System;
using UnityEditor;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Microsoft.Unity.VisualStudio.Editor.Testing
{
[InitializeOnLoad]
internal class TestRunnerApiListener
{
private static readonly TestRunnerApi _testRunnerApi;
private static readonly TestRunnerCallbacks _testRunnerCallbacks;
static TestRunnerApiListener()
{
if (!VisualStudioEditor.IsEnabled)
return;
_testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
_testRunnerCallbacks = new TestRunnerCallbacks();
_testRunnerApi.RegisterCallbacks(_testRunnerCallbacks);
}
public static void RetrieveTestList(string mode)
{
RetrieveTestList((TestMode) Enum.Parse(typeof(TestMode), mode));
}
private static void RetrieveTestList(TestMode mode)
{
_testRunnerApi?.RetrieveTestList(mode, ta => _testRunnerCallbacks.TestListRetrieved(mode, ta));
}
public static void ExecuteTests(string command)
{
// ExecuteTests format:
// TestMode:FullName
var index = command.IndexOf(':');
if (index < 0)
return;
var testMode = (TestMode)Enum.Parse(typeof(TestMode), command.Substring(0, index));
var filter = command.Substring(index + 1);
ExecuteTests(new Filter { testMode = testMode, testNames = new [] { filter } });
}
private static void ExecuteTests(Filter filter)
{
_testRunnerApi?.Execute(new ExecutionSettings(filter));
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0b59b40c84c6a5348a188c16b17c7b40
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
@@ -0,0 +1,90 @@
using System;
using System.Collections.Generic;
using UnityEditor.TestTools.TestRunner.Api;
using UnityEngine;
namespace Microsoft.Unity.VisualStudio.Editor.Testing
{
internal class TestRunnerCallbacks : ICallbacks
{
private string Serialize<TContainer, TSource, TAdaptor>(
TSource source,
Func<TSource, int, TAdaptor> createAdaptor,
Func<TSource, IEnumerable<TSource>> children,
Func<TAdaptor[], TContainer> container)
{
var adaptors = new List<TAdaptor>();
void AddAdaptor(TSource item, int parentIndex)
{
var index = adaptors.Count;
adaptors.Add(createAdaptor(item, parentIndex));
foreach (var child in children(item))
AddAdaptor(child, index);
}
AddAdaptor(source, -1);
return JsonUtility.ToJson(container(adaptors.ToArray()));
}
private string Serialize(ITestAdaptor testAdaptor)
{
return Serialize(
testAdaptor,
(a, parentIndex) => new TestAdaptor(a, parentIndex),
(a) => a.Children,
(r) => new TestAdaptorContainer { TestAdaptors = r });
}
private string Serialize(ITestResultAdaptor testResultAdaptor)
{
return Serialize(
testResultAdaptor,
(a, parentIndex) => new TestResultAdaptor(a, parentIndex),
(a) => a.Children,
(r) => new TestResultAdaptorContainer { TestResultAdaptors = r });
}
public void RunFinished(ITestResultAdaptor testResultAdaptor)
{
VisualStudioIntegration.BroadcastMessage(Messaging.MessageType.RunFinished, Serialize(testResultAdaptor));
}
public void RunStarted(ITestAdaptor testAdaptor)
{
VisualStudioIntegration.BroadcastMessage(Messaging.MessageType.RunStarted, Serialize(testAdaptor));
}
public void TestFinished(ITestResultAdaptor testResultAdaptor)
{
VisualStudioIntegration.BroadcastMessage(Messaging.MessageType.TestFinished, Serialize(testResultAdaptor));
}
public void TestStarted(ITestAdaptor testAdaptor)
{
VisualStudioIntegration.BroadcastMessage(Messaging.MessageType.TestStarted, Serialize(testAdaptor));
}
private static string TestModeName(TestMode testMode)
{
switch (testMode)
{
case TestMode.EditMode: return "EditMode";
case TestMode.PlayMode: return "PlayMode";
}
throw new ArgumentOutOfRangeException();
}
internal void TestListRetrieved(TestMode testMode, ITestAdaptor testAdaptor)
{
// TestListRetrieved format:
// TestMode:Json
var value = TestModeName(testMode) + ":" + Serialize(testAdaptor);
VisualStudioIntegration.BroadcastMessage(Messaging.MessageType.TestListRetrieved, value);
}
}
}

Some files were not shown because too many files have changed in this diff Show More