JetBrains.Platform.ProjectModel.Host

MsBuild Event Logger dll name. Used in

Zone that enables live tracking of changed files. Must be enabled in Rider and ReSharper if it uses and wants to track changed files

Indicates the project has no project configuration in the current solution configuration

Indicates the project has invalid project configuration in the current solution configuration

Extension interface which allows to contribute additional projects (as project marks) into project model Used by plugins

Represents any change in project structure

Represents a project change when the project have to be reloaded via appropriate project host

Project descriptors tree for this change

Corresponding project host

Object which requests this project reload operation

This project reload change is cancelled and should not be used in project loading operations

Represents structure project change (i.e. project parent)

Project to structure update

Collection of descriptors to represent a single IProject in R# project model Part of

Allows to log and project load operations in

Returns a path which should be used to store logs for a project load operation

Cookie for prevent any project modifications in some cases e.g. from file system changes

Store information about all patterns in all projects in format: IncludePattern -> ProjectMark[] -> ExcludePattern[] - We have one general list of all include patterns from all projects - Each include pattern can be presented in several projects - Each include pattern in an project can be presented several times with different exclude patterns

Store all tracking folders and set of dependant projects

Store all folders which should be excluded from tracking

Defines a backend host that owns the authoritative representation of a single IDE project mark. Implementations are responsible for loading, reloading and incrementally updating the project model based on external changes (build system, file system, protocol events), as well as describing items and references for persistence. The host is discovered via ProjectsHostComponent and is selected per project mark using .

Typical lifecycle: - The solution mark creates one or more s. - The Projects Host selects a concrete IProjectHost whose returns true. - is called, then builds a fresh descriptor snapshot. - Later, item/reference edit methods can be used for incremental updates, or can be called again to rebuild the project.

Returns true if this host knows how to handle the given project mark. Used to select a host implementation per mark.

Project identity created by a solution mark. True if the host can manage this project.

Rebuilds the project model for the specified project mark(s). Implementations typically compute a new in-memory descriptor snapshot and pass it back via the provided s.

Lifetime controlling a potentially long-running reload operation. One or more project marks to reload, along with a place to store created descriptors. Callbacks invoked on reload start/finish to update UI and metrics. Optional path where the host can write diagnostic or import logs.

Releases all resources and cached state associated with the given project mark. Implementations should stop file watching, cancel ongoing work and detach descriptors.

The project to unload.

Called before a project is (re)loaded. Gives the host a chance to prepare caches or adjust state.

The project that is about to be loaded.

Returns whether the given change affects this project and requires an update (incremental or full reload).

The project to check. An item that has changed (file, folder, reference, etc.). True if the host should react to the change.

Adds a new item to the project (file or folder). Implementations should place the item according to when provided to keep a stable presentation order.

Target project. Item to add. Placement hint relative to existing item; can be null.

Removes an item from the project.

Target project. Item to remove. A session that must be committed to finalize the change.

Removes an item and marks it as excluded from the project (e.g., adds an exclude entry).

Target project. Item to remove and exclude. A session that must be committed to finalize the change.

Updates metadata or properties of an existing item in the project.

Target project. Item to update. A session that must be committed to finalize the change.

Adds a project-to-module reference (e.g., to another project, package or library).

Target project. Reference to add.

Removes a reference from the project.

Target project. Reference to remove.

Replaces an existing reference with a new one (atomic rebind).

Target project. Reference to remove. Reference to add.

Updates properties/metadata of an existing reference.

Target project. Reference to update. A session that must be committed to finalize the change.

Returns a lightweight description of how the host would represent a given item (build action, metadata, etc.).

Target project. Item to describe. Descriptor describing item type and metadata.

Intended to restart the underlying session (like MSBuild process) after changing toolsets Does not modify the project structure.

Lightweight, immutable identity and basic metadata of a project known to the Projects Host. A project mark is created by an and used to select a suitable implementation. It holds stable identity (GUIDs, unique name) and hierarchical relations used by the solution host. The project host owns the concrete project model built from this mark.

Responsibilities: - Identify a project by location, GUIDs and unique name. - Represent hierarchy (parent/children) for solution folders and composite projects. - Expose configuration/platform currently active for the project. - Provide a change signal () for UI or hosts that mirror hierarchy changes.

Owning solution identity that created this project mark.

Display name of the project as shown in the Solution view. For file-based projects it usually derives from the project file name or directory name. For solution folders it equals the folder name.

Physical location of the project. For file-based projects this is typically the path to the project file; for folder-based projects it is the directory treated as the project root. Implementations should return an absolute path in the solution VFS context.

Stable GUID of the project. Must remain constant across reloads; used as persistent identity.

Project type GUID (e.g., solution folder, MSBuild project type, custom host type). Can be for custom/virtual projects that do not map to a predefined type.

Unique project name used for persistence (solution files, caches). It should be stable and must not change during modifications; the default is usually derived from and .

Parent project mark if this project is nested (e.g., inside a solution folder). Can be null for top-level marks.

Direct children of this project in the hierarchy. Empty for leaf projects.

Currently active configuration and platform for this project as chosen by the solution host.

True if this mark represents a solution folder rather than a buildable project.

True if this project mark allows structural modifications via edit APIs. Non-modifiable marks are managed exclusively by their host and edits should be ignored.

Signal that is fired when the mark or its hierarchy changes (e.g., parent changed, children updated). Consumers can subscribe to react to structural changes.

Changes the parent in the hierarchy. Implementations are expected to update Children collections accordingly and fire .

Detaches this project from the hierarchy, removing it from its parent if any. Should fire .

Efficiently iterates over children without boxing/allocations. The provided context is passed to each callback invocation to avoid closures. Implementations should not allocate per iteration.

Executes an update operation and fires changes if needed

Returns collection of projects from the solution which should be definitely updated along with specified project

Lightweight, authoritative identity of a solution that owns a set of s managed by the Projects Host. An implementation is responsible for naming, locating the solution and orchestrating high-level updates of its projects via . The mark is created by frontend/opening logic and then used by the Solution Host to build and maintain a backend project model.

Responsibilities: - Provide stable solution identity and location (, ). - Create/rename/move/remove s that constitute the solution structure. - Participate in solution structure updates via and expose configuration/platform state.

Display name of the solution as shown in the Solution view.

Physical location that identifies this solution. For file-based solutions it is typically the solution file (e.g., .sln or build-script entry point); for virtual solutions it can be the main definition file.

Rebuilds or incrementally updates the solution structure. Implementations should use from the to create/update project marks and return a describing added/removed/updated projects.

Context with structure builder, current container and update policy. Description of changes to apply to the solution structure.

Returns the solution/platform file format version, if applicable. Unknown when not applicable.

Returns physical locations of projects that belong to this solution. Used for change tracking and fast checks. Implementations should return stable, absolute paths.

Returns additional locations considered part of the solution (e.g., configuration files, generated directories). These locations can be used for diagnostics and file watching.

Currently active configuration/platform pair for the solution.

Store that owns all configurations and platforms known to this solution mark and can compute/fix active state.

Creates a new for the given descriptor and optionally assigns its parent in the solution hierarchy.

Definition describing the project to add. Optional parent project mark (e.g., solution folder). The created project mark.

Renames a project and updates its logical location if needed.

Project to rename. New display name. New physical location (absolute path). The updated project mark.

Removes a project from the solution.

Project to remove.

Moves a project under a new parent (e.g., into a different solution folder).

Project to move. New parent or null to move to the root.

Allows to update a specific project even if it was not changed in the solution definition file

Filter metadata which should be written for the new items

User excluded project from build intentionally, it that case message is empty and we do not consider this diagnostic as an issue

Listens to loaded MSBuild projects and provides diagnostics to report them to the user Should be [SolutionInstanceComponent] or [ShellComponent]

Marker interface for diagnostics which can be fixed by installing (different) MSBuild

Marker interface for diagnostics which means MSBuild process can not be started

Fills additional project information based on msbuild project properties

Constructs build settings based on generic msbuild project (without specific target framework)

Constructs configurations based on msbuild project part loaded for specific target framework

Run targets to generate objc bindings, see https://github.com/xamarin/xamarin-macios/blob/master/msbuild/Xamarin.Mac.Tasks/Xamarin.Mac.ObjCBinding.CSharp.targets

Filter project item with if other project item with the same location with presented in the same project

Represents default project file build actions in a project

Collection of build actions applied to this project by default

Allows to produce default project build action from MSBuild project item(s)

Returns array of project file extensions where MsBuild Task should use simple modifications instead of default (smart) behavior Extension should be specified without dot

Method is called each time after project is loaded/reloaded Call happens immediately after getting results from MsBuild: - usually on background thread - before updating R# project model

Method is called each time after project is loaded/reloaded Call happens immediately after getting results from MsBuild: - usually on background thread - before updating R# project model

Method is called each time before several projects are loaded/reloaded Created session will be called for each loaded projects and thn Dispose will be called in the end

Defines which MSBuild items, properties and metadata should be retrieved from MSBuild external process during project model construction Should be defined as a ShellComponent

Filtered -> Existing Map Example: "None" should be filtered when "Content" is presented "None" -> "Content"

Default MsBuild item types, allowed in any type of msbuild project.

Discovers project type using loaded msbuild project and a number of hacks

Prefer these items when we have several items with different build actions

Build wildcard pattern based on Microsoft.Build.Shared.FileMatcher implementation

Components for loading solution/project file and create project descriptors Use for update existing solution or load descriptors from disk Use from control solution lifecycle inside resharper This component container allows to compose a component container each time when we need to load solution or project, SolutionInstance component container doesn't allow this

Returns project for the project mark if there is only one in the solution

Returns all projects for the project mark in the solution

Use this method wherever the single build action for a project file required, for example in MsBuild interations or UI

Encapsulates alghoritm to build project model descriptors (folders and files inside a IProjectDescriptor) from different `abstract` items

Returns file origin

Fills additional data from this file into project file properties

Executes when there are other files with the same location Returns true if this file should be filtered in this case

Logical path to the element in project model and solution explorer Can be null, that means physical path is the same as logical path

Physical path to the element in file system (can point to any path on any disk)

Return true if an external folder could be hidden from project hierarchy

Physical path to the element in file system (can point to any path on any disk)

Logical name (if any)

List of build actions per target framework

List of original project items, will be used to create IProjectElementOrigin and file properties

Non-linked folder path inside a project, used to resolve conflicts between several physical (linked) folders, see myPhysicalPaths field

One project folder can be used for several physical paths (one - inside a project and others - linked)

Folder names and counts to choose the most actual case for the folder name

Project folders can be duplicated in case of linked files. Example: - Project [c:\project] - Data [c:\project\data] - Data [c:\some_other_folder\data] In that case we want to merge all these folders with the same names

If we have only linked items there might be 1 excessive level of nestedness. Example: - Project [c:\project\project.proj] - Data [c:\some_other_folder\data] - Folder [c:\some_other_folder\data\folder] - File1 [c:\some_other_folder\data\file1] - File2 [c:\some_other_folder\data\file2] In that case we want to get rid of it and move files one level higher (especially in UE4). But Unity expects this project structure (see RIDER-58975). So we're applying this logic only to C++ projects.

True if executor can perform some operation

Performs some reload operation

All these event fire from background thread

Encapsulates additional logic to store and recover project model from persistent caches

Component tracks all current changes in project model in two ways 1) Active reloading projects 2) Active reloading processes count (there are changes without affected projects, but we want to track them anyway) Also component allows to queue (or execute immediately) an action as soon as no loading processes executing now

Controls ReSharper Solution life-cycle based on solution / project marks reading

We should not patch references in that way when we have actual (real) project model

Returns true when solution was already synced once

Returns true when there are no sync project operations (active or pending)

Returns true when there are no sync project operations (active or pending) and there are no background tasks which can trigger projects reloading

Reload projects synchronously, use this method with carefully, async reloading is usually better

Reload projects async

Suspends ASYNC project reloading until lifetime will be terminated

Batch operation for adding and removing projects

If added projects depend on each other - then dependent project should follow after parent

Returns how much time Rider spent loading and reloading projects in this solution since startup

Monitors state of loading/reloading/unloading ant projects in SolutionHost

True when SolutionHost performs any loading project operations Changes only on UI thread

Execute action when there is no pending loading operations and on UI thread Method can be invoked from UI/Background threads

This key stores origin project ID, i.e. some information from which source project was created For example: name + guid written in a solution file

Provides platforms from NuGet packages per project

Assemblies in NuGet folders can be deleted and restored again

PermanentHeader will be ignored

Header will be ignored

PermanentDescription, DescriptionFromProgress will be ignored

Description, DescriptionFromProgress will be ignored

Description, PermanentDescription will be ignored

IsIndeterminate will be ignored. The current position of the progress, in the [0..1] range, inclusive.

Progress will be ignored

CancelAction will be ignored

This proxy class is requires because we start solution loading progress before component container is constructed so we will need use these progresses from "shell" level and then "pick up" them when container will be initialized

Reload a project synchronously, use this method with carefully, async reloading is usually better

Reload a project async

Tells how solution was loaded - cold (without caches) or warm (from caches)

Solution was NOT loaded from caches

Solution was loaded from caches

Util component to load or update solution once without control solutuion lifecycle

Should return same as com.jetbrains.rider.utils.ProjectTypeGuidGuesser.Companion#calculateTypeGuid Also see JetBrains.Platform.MsBuildTask.Utils.ProjectTypeGuidGuesser