This is currently an experiment.

• Adds a new type: FSharpProject
  • The type represents a F# project for use in an IDE/editor and is internally implemented by an incremental builder which contains the state; the state is immutable.
  • The type can be instantiated separately from FSharpChecker.
  • Because the internal state is immutable, any logical update that needs to be done to the project will result in the creation of a new FSharpProject instance; effectively making it a snapshot.
  • This is useful for few reasons:
    • Synchronizing IDE/editor's view of a project with FSharpProject becomes easier to manage as the IDE/editor is in charge of maintaining the state rather than FCS; this is hugely important.
    • Making an update to a FSharpProject will not impact other FSharpProject instances.
    • Being able to reason about the state of a FSharpProject is easier.
  • Open Questions
    • How is type provider invalidation going to be handled? Type providers can inherently be mutable, making the FSharpProject technically not immutable if it references a type provider.
    • Do we have any APIs that rely on forward looking ahead of files in a project?

Acceptance Criteria

• Move out of 'Experimental' mode
• Review API Design
• Integrate into VS
• Tests