private async Task StartUndoAsync(CancellationToken token = default)
            {
                DTE dte = await _dte.GetValueAsync(token);

                if (dte.UndoContext.IsOpen)
                {
                    _shouldClose = false;
                }
                dte.UndoContext.Open(_renameOperationName, false);
            }
Exemple #2
0
        public async Task InitializeAsync()
        {
            await _threadHandling.Value.SwitchToUIThread();

            // Initialize our cache file
            string appDataFolder = await _shellUtilitiesHelper.Value.GetLocalAppDataFolderAsync(_vsShellService);

            if (appDataFolder != null)
            {
                _versionDataCacheFile = new RemoteCacheFile(Path.Combine(appDataFolder, VersionDataFilename), VersionCompatibilityDownloadFwlink,
                                                            TimeSpan.FromHours(CacheFileValidHours), _fileSystem.Value, _httpClient);
            }

            _ourVSVersion = await _shellUtilitiesHelper.Value.GetVSVersionAsync(_vsAppIdService);

            _vsSolution = await _vsSolutionService.GetValueAsync();

            Verify.HResult(_vsSolution.AdviseSolutionEvents(this, out _solutionCookie));

            // Check to see if a solution is already open. If so we set _solutionOpened to true so that subsequent projects added to
            // this solution are processed.
            if (ErrorHandler.Succeeded(_vsSolution.GetProperty((int)__VSPROPID4.VSPROPID_IsSolutionFullyLoaded, out object isFullyLoaded)) &&
                isFullyLoaded is bool isFullyLoadedBool &&
                isFullyLoadedBool)
            {
                _solutionOpened = true;
            }
        }
        /// <summary>
        /// Launches the Visual Studio debugger.
        /// </summary>
        protected async Task DoLaunchAsync(IVsDebuggerLaunchCompletionCallback cb, params IDebugLaunchSettings[] launchSettings)
        {
            if (launchSettings.Length == 0)
            {
                cb.OnComplete(0, 0, null);
                return;
            }

            VsDebugTargetInfo4[] launchSettingsNative = launchSettings.Select(GetDebuggerStruct4).ToArray();

            try
            {
                // The debugger needs to be called on the UI thread
                await ThreadingService.SwitchToUIThread();

                IVsDebuggerLaunchAsync shellDebugger = await _vsDebuggerService.GetValueAsync();

                shellDebugger.LaunchDebugTargetsAsync((uint)launchSettingsNative.Length, launchSettingsNative, cb);
            }
            finally
            {
                // Free up the memory allocated to the (mostly) managed debugger structure.
                foreach (VsDebugTargetInfo4 nativeStruct in launchSettingsNative)
                {
                    FreeVsDebugTargetInfoStruct(nativeStruct);
                }
            }
        }
Exemple #4
0
        internal Task OnProjectChangedAsync(IProjectVersionedValue <IProjectSubscriptionUpdate>?_ = null)
        {
            return(_projectTasksService.LoadedProjectAsync(async() =>
            {
                bool isDebuggable = await IsDebuggableAsync();

                IVsStartupProjectsListService?startupProjectsListService = await _startupProjectsListService.GetValueAsync();

                if (startupProjectsListService == null)
                {
                    return;
                }

                if (isDebuggable)
                {
                    // If we're already registered, the service no-ops
                    startupProjectsListService.AddProject(ref _projectGuid);
                }
                else
                {
                    // If we're already unregistered, the service no-ops
                    startupProjectsListService.RemoveProject(ref _projectGuid);
                }
            }));
        }
        // This method is overridden in test code
        protected virtual async Task <bool> IsPreviewSDKInUseAsync()
        {
            if (await _shellUtilitiesHelper.Value.IsVSFromPreviewChannelAsync())
            {
                return(true);
            }

            if (_settingsManagerService == null)
            {
                return(false);
            }

            ISettingsManager settings = await _settingsManagerService.GetValueAsync();

            return(settings.GetValueOrDefault <bool>(UsePreviewSdkSettingKey));
        }
Exemple #6
0
        /// <summary>
        /// Launches the Visual Studio debugger.
        /// </summary>
        protected async Task <IReadOnlyList <VsDebugTargetProcessInfo> > DoLaunchAsync(params IDebugLaunchSettings[] launchSettings)
        {
            VsDebugTargetInfo4[] launchSettingsNative = launchSettings.Select(GetDebuggerStruct4).ToArray();
            if (launchSettingsNative.Length == 0)
            {
                return(Array.Empty <VsDebugTargetProcessInfo>());
            }

            try
            {
                // The debugger needs to be called on the UI thread
                await ThreadingService.SwitchToUIThread();

                IVsDebugger4 shellDebugger = await _vsDebuggerService.GetValueAsync();

                var launchResults = new VsDebugTargetProcessInfo[launchSettingsNative.Length];
                shellDebugger.LaunchDebugTargets4((uint)launchSettingsNative.Length, launchSettingsNative, launchResults);
                return(launchResults);
            }
            finally
            {
                // Free up the memory allocated to the (mostly) managed debugger structure.
                foreach (VsDebugTargetInfo4 nativeStruct in launchSettingsNative)
                {
                    FreeVsDebugTargetInfoStruct(nativeStruct);
                }
            }
        }
Exemple #7
0
        // This method is overridden in test code
        protected virtual async Task<bool> IsPreviewSDKInUseAsync()
        {
            if (await IsPrereleaseAsync())
            {
                return true;
            }

            if (_settingsManagerService == null)
            {
                return false;
            }

            ISettingsManager settings = await _settingsManagerService.GetValueAsync();

            return settings.GetValueOrDefault<bool>(UsePreviewSdkSettingKey);
        }
Exemple #8
0
        public async Task <Version?> GetVSVersionAsync(IVsService <IVsAppId> vsAppIdService)
        {
            await _threadingService.SwitchToUIThread();

            IVsAppId?vsAppId = await vsAppIdService.GetValueAsync();

            Assumes.Present(vsAppId);

            if (ErrorHandler.Succeeded(vsAppId.GetProperty((int)VSAPropID.VSAPROPID_ProductSemanticVersion, out object oVersion)) &&
                oVersion is string semVersion)
            {
                // This is a semantic version string. We only care about the non-semantic version part
                int index = semVersion.IndexOfAny(Delimiter.PlusAndMinus);
                if (index != -1)
                {
                    semVersion = semVersion.Substring(0, index);
                }

                if (Version.TryParse(semVersion, out Version vsVersion))
                {
                    return(vsVersion);
                }
            }

            return(null);
        }
            private async Task <Project?> TryGetProjectFromPathAsync(string projectPath)
            {
                DTE?dte = await _dte.GetValueAsync();

                Assumes.NotNull(dte);

                foreach (Project project in dte.Solution.Projects)
                {
                    string?fullName = null;
                    try
                    {
                        fullName = project.FullName;
                    }
                    catch (Exception)
                    {
                        // DTE COM calls can fail for any number of valid reasions.
                        continue;
                    }

                    if (StringComparers.Paths.Equals(fullName, projectPath))
                    {
                        return(project);
                    }
                }

                return(null);
            }
        // This method is overridden in test code
        protected virtual async Task <bool> IsPreviewSDKInUseAsync()
        {
            if (await IsPrereleaseAsync())
            {
                return(true);
            }

            if (_settingsManagerService == null)
            {
                return(false);
            }

            ISettingsManager?settings = await _settingsManagerService.GetValueAsync();

            Assumes.Present(settings);

            return(settings.GetValueOrDefault <bool>(UsePreviewSdkSettingKey));
        }
Exemple #11
0
        private async Task ProcessDesignTimeInputs(IProjectVersionedValue <DesignTimeInputs> input)
        {
            DesignTimeInputs designTimeInputs = input.Value;

            IVsAsyncFileChangeEx?vsAsyncFileChangeEx = await _fileChangeService.GetValueAsync();

            Assumes.Present(vsAsyncFileChangeEx);

            // we don't care about the difference between types of inputs, so we just construct one hashset for fast comparisons later
            var allFiles = new HashSet <string>(StringComparers.Paths);

            allFiles.AddRange(designTimeInputs.Inputs);
            allFiles.AddRange(designTimeInputs.SharedInputs);

            // Remove any files we're watching that we don't care about any more
            var removedFiles = new List <string>();

            foreach ((string file, uint cookie) in _fileWatcherCookies)
            {
                if (!allFiles.Contains(file))
                {
                    await vsAsyncFileChangeEx.UnadviseFileChangeAsync(cookie);

                    removedFiles.Add(file);
                }
            }

            foreach (string file in removedFiles)
            {
                _fileWatcherCookies.Remove(file);
            }

            // Now watch and output files that are new
            foreach (string file in allFiles)
            {
                if (!_fileWatcherCookies.ContainsKey(file))
                {
                    // We don't care about delete and add here, as they come through data flow, plus they are really bouncy - every file change is a Time, Del and Add event)
                    uint cookie = await vsAsyncFileChangeEx.AdviseFileChangeAsync(file, _VSFILECHANGEFLAGS.VSFILECHG_Time | _VSFILECHANGEFLAGS.VSFILECHG_Size, sink : this);

                    _fileWatcherCookies.Add(file, cookie);
                }
            }
        }
        private async Task RegisterFileWatcherAsync(string projectLockJsonFilePath)
        {
            // Note file change service is free-threaded
            if (projectLockJsonFilePath != null)
            {
                _previousContentsHash = GetFileHashOrNull(projectLockJsonFilePath);
                _taskDelayScheduler   = new TaskDelayScheduler(
                    s_notifyDelay,
                    _projectServices.ThreadingService,
                    CreateLinkedCancellationToken());

                IVsFileChangeEx fileChangeService = await _fileChangeService.GetValueAsync();

                int hr = fileChangeService.AdviseFileChange(projectLockJsonFilePath, (uint)(_VSFILECHANGEFLAGS.VSFILECHG_Time | _VSFILECHANGEFLAGS.VSFILECHG_Size | _VSFILECHANGEFLAGS.VSFILECHG_Add | _VSFILECHANGEFLAGS.VSFILECHG_Del), this, out _filechangeCookie);
                ErrorHandler.ThrowOnFailure(hr);
            }

            _fileBeingWatched = projectLockJsonFilePath;
        }
        protected virtual async Task <bool> IsPreviewSDKInUseAsync()
        {
            if (await IsPrereleaseAsync())
            {
                return(true);
            }

            ISettingsManager settings = await _settingsManagerService?.GetValueAsync();

            return(settings.GetValueOrDefault <bool>(s_usePreviewSdkSettingKey));
        }
Exemple #14
0
            private async Task <IVsHierarchy?> TryGetIVsHierarchyAsync(Project project)
            {
                IVsSolution solutionService = await _solutionService.GetValueAsync();

                if (solutionService.GetProjectOfUniqueName(project.UniqueName, out IVsHierarchy projectHierarchy) == HResult.OK)
                {
                    return(projectHierarchy);
                }

                return(null);
            }
        private async Task <Solution> PublishLatestSolutionAsync()
        {
            // WORKAROUND: We don't yet have a way to wait for the rename changes to propagate
            // to Roslyn (tracked by https://github.com/dotnet/project-system/issues/3425), so
            // instead we wait for the IntelliSense stage to finish for the entire solution
            //
            IVsOperationProgressStageStatus stageStatus = (await _operationProgressService.GetValueAsync()).GetStageStatus(CommonOperationProgressStageIds.Intellisense);
            await stageStatus.WaitForCompletionAsync();

            // The result of that wait, is basically a "new" published Solution, so grab it
            return(_workspace.CurrentSolution);
        }
Exemple #16
0
        private async Task WarnUserOfIncompatibleProjectAsync(CompatibilityLevel compatLevel, VersionCompatibilityData compatData)
        {
            // Warn the user.
            await _threadHandling.Value.SwitchToUIThread();

            // Check if already warned - this could happen in the off chance two projects are added very quickly since the detection work is
            // scheduled on idle.
            if (_compatibilityLevelWarnedForThisSolution < compatLevel)
            {
                // Only want to warn once per solution
                _compatibilityLevelWarnedForThisSolution = compatLevel;

                IVsUIShell uiShell = await _vsUIShellService.GetValueAsync();

                uiShell.GetAppName(out string caption);

                if (compatLevel == CompatibilityLevel.Supported)
                {
                    // Get current dontShowAgain value
                    ISettingsManager settingsManager = await _settingsManagerService.GetValueAsync();

                    bool suppressPrompt = false;
                    if (settingsManager != null)
                    {
                        suppressPrompt = settingsManager.GetValueOrDefault(SuppressDotNewCoreWarningKey, defaultValue: false);
                    }

                    if (!suppressPrompt)
                    {
                        string msg = string.Format(compatData.OpenSupportedMessage, compatData.SupportedVersion.Major, compatData.SupportedVersion.Minor);
                        suppressPrompt = _dialogServices.Value.DontShowAgainMessageBox(caption, msg, VSResources.DontShowAgain, false, VSResources.LearnMore, SupportedLearnMoreFwlink);
                        if (suppressPrompt && settingsManager != null)
                        {
                            await settingsManager.SetValueAsync(SuppressDotNewCoreWarningKey, suppressPrompt, isMachineLocal : true);
                        }
                    }
                }
                else
                {
                    string msg;
                    if (compatData.UnsupportedVersion != null)
                    {
                        msg = string.Format(compatData.OpenUnsupportedMessage, compatData.UnsupportedVersion.Major, compatData.UnsupportedVersion.Minor);
                    }
                    else
                    {
                        msg = string.Format(compatData.OpenUnsupportedMessage, compatData.SupportedVersion.Major, compatData.SupportedVersion.Minor);
                    }

                    _dialogServices.Value.DontShowAgainMessageBox(caption, msg, null, false, VSResources.LearnMore, UnsupportedLearnMoreFwlink);
                }
            }
        }
        public async Task <string?> GetRegistryRootAsync(IVsService <IVsShell> vsShellService)
        {
            await _threadingService.SwitchToUIThread();

            IVsShell shell = await vsShellService.GetValueAsync();

            if (ErrorHandler.Succeeded(shell.GetProperty((int)__VSSPROPID.VSSPROPID_VirtualRegistryRoot, out object value)))
            {
                return(value as string);
            }

            return(null);
        }
        private async Task RegisterFileWatcherAsync(string projectLockJsonFilePath)
        {
            // Note file change service is free-threaded
            if (projectLockJsonFilePath != null)
            {
                _previousContentsHash = GetFileHashOrNull(projectLockJsonFilePath);
                _taskDelayScheduler?.Dispose();
                _taskDelayScheduler = new TaskDelayScheduler(
                    s_notifyDelay,
                    _projectServices.ThreadingService,
                    CreateLinkedCancellationToken());

                IVsAsyncFileChangeEx fileChangeService = await _fileChangeService.GetValueAsync();

                _filechangeCookie = await fileChangeService.AdviseFileChangeAsync(
                    projectLockJsonFilePath,
                    _VSFILECHANGEFLAGS.VSFILECHG_Time | _VSFILECHANGEFLAGS.VSFILECHG_Size | _VSFILECHANGEFLAGS.VSFILECHG_Add | _VSFILECHANGEFLAGS.VSFILECHG_Del,
                    sink : this);
            }

            _fileBeingWatched = projectLockJsonFilePath;
        }
Exemple #19
0
        public async Task <string?> GetLocalAppDataFolderAsync(IVsService <IVsShell> vsShellService)
        {
            await _threadingService.SwitchToUIThread();

            IVsShell?shell = await vsShellService.GetValueAsync();

            if (ErrorHandler.Succeeded(shell !.GetProperty((int)__VSSPROPID4.VSSPROPID_LocalAppDataDir, out object objDataFolder)) && objDataFolder is string appDataFolder)
            {
                return(appDataFolder);
            }

            return(null);
        }
Exemple #20
0
        private async Task EnsureBuildManagerInitializedAsync()
        {
            // Switch to UI thread for querying the build manager service.
            await _threadingService.SwitchToUIThread();

            if (_buildManager == null)
            {
                _buildManager = await _vsSolutionBuildManagerService.GetValueAsync();

                // Register for solution build events.
                _buildManager !.AdviseUpdateSolutionEvents(this, out _solutionEventsCookie);
            }
        }
        // This method is overridden in test code
        protected virtual async Task <bool> IsPreviewSDKInUseAsync()
        {
            ISetupInstanceCatalog setupInstanceCatalog = await TryGetSetupInstanceAsync();

            if (setupInstanceCatalog?.IsPrerelease() == true)
            {
                return(true);
            }

            ISettingsManager settings = await _settingsManagerService?.GetValueAsync();

            return(settings.GetValueOrDefault <bool>(UsePreviewSdkSettingKey));
        }
Exemple #22
0
            private async Task <Project?> TryGetProjectFromPathAsync(string projectPath)
            {
                DTE dte = await _dte.GetValueAsync();

                foreach (Project project in dte.Solution.Projects)
                {
                    if (StringComparers.Paths.Equals(project.FullName, projectPath))
                    {
                        return(project);
                    }
                }

                return(null);
            }
        protected override async Task InitializeCoreAsync(CancellationToken cancellationToken)
        {
            // AdviseUpdateSolutionEvents call needs UI thread.
            await JoinableFactory.SwitchToMainThreadAsync(cancellationToken);

            _solutionBuildManager = await _solutionBuildManagerService.GetValueAsync(cancellationToken);

            (_solutionBuildManager as IVsSolutionBuildManager2)?.AdviseUpdateSolutionEvents(this, out _cookie);
            ErrorHandler.ThrowOnFailure(_solutionBuildManager.AdviseUpdateSolutionEvents3(this, out _cookie3));

            _skipAnalyzersForImplicitlyTriggeredBuild = await _options.GetSkipAnalyzersForImplicitlyTriggeredBuildAsync(cancellationToken);

            _options.RegisterOptionChangedEventHandler(OnOptionChangedAsync);
        }
Exemple #24
0
        public async Task <string?> GetLocalAppDataFolderAsync(IVsService <IVsShell> vsShellService)
        {
            await _threadingService.SwitchToUIThread();

            IVsShell?shell = await vsShellService.GetValueAsync();

            Assumes.Present(shell);

            if (ErrorHandler.Succeeded(shell.GetProperty((int)__VSSPROPID4.VSSPROPID_LocalAppDataDir, out object value)))
            {
                return(value as string);
            }

            return(null);
        }
        public LanguageServiceErrorListProvider(
            UnconfiguredProject project,
            IActiveWorkspaceProjectContextHost projectContextHost,
            IVsService <SVsFeatureFlags, IVsFeatureFlags> featureFlagsService,
            JoinableTaskContext joinableTaskContext)
        {
            _project            = project;
            _projectContextHost = projectContextHost;

            _isLspPullDiagnosticsEnabled = new AsyncLazy <bool>(async() =>
            {
                IVsFeatureFlags?service = await featureFlagsService.GetValueAsync();
                return(service.IsFeatureEnabled(LspPullDiagnosticsFeatureFlagName, defaultValue: false));
            }, joinableTaskContext.Factory);
        }
        public async Task InitializeAsync()
        {
            await _threadHandling.Value.SwitchToUIThread();

            // Initialize our cache file
            string?appDataFolder = await _shellUtilitiesHelper.Value.GetLocalAppDataFolderAsync(_vsShellService);

            if (appDataFolder != null)
            {
                _versionDataCacheFile = new RemoteCacheFile(Path.Combine(appDataFolder, VersionDataFilename), VersionCompatibilityDownloadFwlink,
                                                            TimeSpan.FromHours(CacheFileValidHours), _fileSystem.Value, _httpClient);
            }

            VisualStudioVersion = await _shellUtilitiesHelper.Value.GetVSVersionAsync(_vsAppIdService);

            _vsSolution = await _vsSolutionService.GetValueAsync();

            Verify.HResult(_vsSolution.AdviseSolutionEvents(this, out _solutionCookie));

            // Check to see if a solution is already open. If so we set _solutionOpened to true so that subsequent projects added to
            // this solution are processed.
            if (ErrorHandler.Succeeded(_vsSolution.GetProperty((int)__VSPROPID4.VSPROPID_IsSolutionFullyLoaded, out object isFullyLoaded)) &&
                isFullyLoaded is bool isFullyLoadedBool &&
                isFullyLoadedBool)
            {
                SolutionOpen = true;
                // do not block package initialization on this
                _threadHandling.Value.RunAndForget(async() =>
                {
                    // Perform file IO on the thread pool
                    await TaskScheduler.Default;

                    // First make sure that the cache file exists
                    if (_versionDataCacheFile != null && !_versionDataCacheFile.CacheFileExists())
                    {
                        await _versionDataCacheFile.TryToUpdateCacheFileAsync();
                    }

                    // check if the project is compatible
                    await CheckCompatibilityAsync();
                }, unconfiguredProject: null);
            }
        }
Exemple #27
0
        private async Task <IVsContainedLanguageFactory> GetContainedLanguageFactoryAsync()
        {
            Guid languageServiceId = await GetLanguageServiceId();

            if (languageServiceId == Guid.Empty)
            {
                return(null);
            }

            IOleAsyncServiceProvider serviceProvider = await _serviceProvider.GetValueAsync();

            object service = await serviceProvider.QueryServiceAsync(ref languageServiceId);

            // NOTE: While this type is implemented in Roslyn, we force the cast on
            // the UI thread because they are free to change this to an STA object
            // which would result in an RPC call from a background thread.
            await _projectVsServices.ThreadingService.SwitchToUIThread();

            return((IVsContainedLanguageFactory)service);
        }
Exemple #28
0
        private async Task <bool> CheckUserConfirmationAsync(string oldFileName)
        {
            ISettingsManager settings = await _settingsManagerService.GetValueAsync();

            bool enableSymbolicRename = settings.GetValueOrDefault("SolutionNavigator.EnableSymbolicRename", false);

            await _projectVsServices.ThreadingService.SwitchToUIThread();

            bool userNeedPrompt = _environmentOptions.GetOption("Environment", "ProjectsAndSolution", "PromptForRenameSymbol", false);

            if (!enableSymbolicRename || !userNeedPrompt)
            {
                return(enableSymbolicRename);
            }

            string renamePromptMessage = string.Format(CultureInfo.CurrentCulture, VSResources.RenameSymbolPrompt, oldFileName);

            bool userSelection = _userNotificationServices.Confirm(renamePromptMessage, out bool disablePromptMessage);

            _environmentOptions.SetOption("Environment", "ProjectsAndSolution", "PromptForRenameSymbol", !disablePromptMessage);

            return(userSelection);
        }
        private async Task <bool> CheckUserConfirmationAsync(string oldFileName)
        {
            ISettingsManager settings = await _settingsManagerService.GetValueAsync();

            // Default value needs to match the default value in the checkbox Tools|Options|Project and Solutions|Enable symbolic renaming.
            bool enableSymbolicRename = settings.GetValueOrDefault(SymbolicRenameName, true);

            await _projectVsServices.ThreadingService.SwitchToUIThread();

            bool userNeedPrompt = _environmentOptions.GetOption(RenameSymbolCategory, RenameSymbolPage, RenameSymbolOption, false);

            if (!enableSymbolicRename || !userNeedPrompt)
            {
                return(enableSymbolicRename);
            }

            string renamePromptMessage = string.Format(CultureInfo.CurrentCulture, VSResources.RenameSymbolPrompt, oldFileName);

            bool userSelection = _userNotificationServices.Confirm(renamePromptMessage, out bool disablePromptMessage);

            _environmentOptions.SetOption(RenameSymbolCategory, RenameSymbolPage, RenameSymbolOption, !disablePromptMessage);

            return(userSelection);
        }
        private async Task <T> GetSettingValueOrDefaultAsync <T>(string name, T defaultValue, CancellationToken cancellationToken)
        {
            ISettingsManager settingsManager = await _settingsManager.GetValueAsync(cancellationToken);

            return(settingsManager.GetValueOrDefault(name, defaultValue));
        }