// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.

/// Contains logic to coordinate the parsing and checking of one or a group of files

module internal FSharp.Compiler.ParseAndCheckInputs

open System.IO

open Internal.Utilities.Library

open FSharp.Compiler.CheckBasics

open FSharp.Compiler.CheckDeclarations

open FSharp.Compiler.CompilerConfig

open FSharp.Compiler.CompilerImports

open FSharp.Compiler.Diagnostics

open FSharp.Compiler.DependencyManager

open FSharp.Compiler.DiagnosticsLogger

open FSharp.Compiler.GraphChecking

open FSharp.Compiler.NameResolution

open FSharp.Compiler.Syntax

open FSharp.Compiler.TcGlobals

open FSharp.Compiler.Text

open FSharp.Compiler.TypedTree

open FSharp.Compiler.UnicodeLexing

/// Auxiliary type for re-using signature information in TcEnvFromImpls.

///

/// TcState has two typing environments: TcEnvFromSignatures && TcEnvFromImpls

/// When type checking a file, depending on the type (implementation or signature), it will use one of these typing environments (TcEnv).

/// Checking a file will populate the respective TcEnv.

///

/// When a file has a dependencies, the information of the signature file in case a pair (implementation file backed by a signature) will suffice to type-check that file.

/// Example: if `B.fs` has a dependency on `A`, the information of `A.fsi` is enough for `B.fs` to type-check, on condition that information is available in the TcEnvFromImpls.

/// We introduce a special ArtificialImplFile node in the graph to satisfy this. `B.fs -> [ A.fsi ]` becomes `B.fs -> [ ArtificialImplFile A ].

/// The `ArtificialImplFile A` node will duplicate the signature information which A.fsi provided earlier.

/// Processing a `ArtificialImplFile` node will add the information from the TcEnvFromSignatures to the TcEnvFromImpls.

/// This means `A` will be known in both TcEnvs and therefor `B.fs` can be type-checked.

/// By doing this, we can speed up the graph processing as type checking a signature file is less expensive than its implementation counterpart.

///

/// When we need to actually type-check an implementation file backed by a signature, we cannot have the duplicate information of the signature file present in TcEnvFromImpls.

/// Example `A.fs -> [ A.fsi ]`. An implementation file always depends on its signature.

/// Type-checking `A.fs` will add the actual information to TcEnvFromImpls and we do not depend on the `ArtificialImplFile A` for `A.fs`.

///

/// In order to deal correctly with the `ArtificialImplFile` logic, we need to transform the resolved graph to contain the additional pair nodes.

/// After we have type-checked the graph, we exclude the ArtificialImplFile nodes as they are not actual physical files in our project.

[<RequireQualifiedAccess>]

type NodeToTypeCheck =

/// A real physical file in the current project.

/// This can be either an implementation or a signature file.

| PhysicalFile of fileIndex: FileIndex

/// An artificial node that will add the earlier processed signature information to the TcEnvFromImpls.

/// Dependents on this type of node will perceive that a file is known in both TcEnvFromSignatures and TcEnvFromImpls.

/// Even though the actual implementation file was not type-checked.

| ArtificialImplFile of signatureFileIndex: FileIndex

val IsScript: string -> bool

val ComputeQualifiedNameOfFileFromUniquePath: range * string list -> QualifiedNameOfFile

val PrependPathToInput: Ident list -> ParsedInput -> ParsedInput

/// State used to de-deduplicate module names along a list of file names

type ModuleNamesDict = Map<string, Map<string, QualifiedNameOfFile>>

/// Checks if a ParsedInput is using a module name that was already given and deduplicates the name if needed.

val DeduplicateParsedInputModuleName: ModuleNamesDict -> ParsedInput -> ParsedInput * ModuleNamesDict

/// Parse a single input (A signature file or implementation file)

val ParseInput:

lexer: (Lexbuf -> Parser.token) *

diagnosticOptions: FSharpDiagnosticOptions *

diagnosticsLogger: DiagnosticsLogger *

lexbuf: Lexbuf *

defaultNamespace: string option *

fileName: string *

isLastCompiland: (bool * bool) *

identCapture: bool *

userOpName: string option ->

ParsedInput

/// A general routine to process hash directives

val ProcessMetaCommandsFromInput:

('T -> range * string * Directive -> 'T) * ('T -> range * string -> unit) ->

TcConfigBuilder * ParsedInput * string * 'T ->

'T

/// Process all the #r, #I etc. in an input.

val ApplyMetaCommandsFromInputToTcConfig: TcConfig * ParsedInput * string * DependencyProvider -> TcConfig

/// Parse one input stream

val ParseOneInputStream:

tcConfig: TcConfig *

lexResourceManager: Lexhelp.LexResourceManager *

fileName: string *

isLastCompiland: (bool * bool) *

diagnosticsLogger: DiagnosticsLogger *

retryLocked: bool *

stream: Stream ->

ParsedInput

/// Parse one input source text

val ParseOneInputSourceText:

tcConfig: TcConfig *

lexResourceManager: Lexhelp.LexResourceManager *

fileName: string *

isLastCompiland: (bool * bool) *

diagnosticsLogger: DiagnosticsLogger *

sourceText: ISourceText ->

ParsedInput

/// Parse one input file

val ParseOneInputFile:

tcConfig: TcConfig *

lexResourceManager: Lexhelp.LexResourceManager *

fileName: string *

isLastCompiland: (bool * bool) *

diagnosticsLogger: DiagnosticsLogger *

retryLocked: bool ->

ParsedInput

val ParseOneInputLexbuf:

tcConfig: TcConfig *

lexResourceManager: Lexhelp.LexResourceManager *

lexbuf: Lexbuf *

fileName: string *

isLastCompiland: (bool * bool) *

diagnosticsLogger: DiagnosticsLogger ->

ParsedInput

val EmptyParsedInput: fileName: string * isLastCompiland: (bool * bool) -> ParsedInput

/// Parse multiple input files from disk

val ParseInputFiles:

tcConfig: TcConfig *

lexResourceManager: Lexhelp.LexResourceManager *

sourceFiles: string list *

diagnosticsLogger: DiagnosticsLogger *

retryLocked: bool ->

(ParsedInput * string) list

/// Process collected directives

val FinishPreprocessing: Lexbuf -> FSharpDiagnosticOptions -> bool -> range list -> unit

/// Get the initial type checking environment including the loading of mscorlib/System.Core, FSharp.Core

/// applying the InternalsVisibleTo in referenced assemblies and opening 'Checked' if requested.

val GetInitialTcEnv: assemblyName: string * range * TcConfig * TcImports * TcGlobals -> TcEnv * OpenDeclaration list

/// Represents the incremental type checking state for a set of inputs

[<Sealed>]

type TcState =

/// The CcuThunk for the current assembly being checked

member Ccu: CcuThunk

/// Get the typing environment implied by the set of signature files and/or inferred signatures of implementation files checked so far

member TcEnvFromSignatures: TcEnv

/// Get the typing environment implied by the set of implementation files checked so far

member TcEnvFromImpls: TcEnv

/// The inferred contents of the assembly, containing the signatures of all files.

// a.fsi + b.fsi + c.fsi (after checking implementation file for c.fs)

member CcuSig: ModuleOrNamespaceType

member NextStateAfterIncrementalFragment: TcEnv -> TcState

member CreatesGeneratedProvidedTypes: bool

type PartialResult = TcEnv * TopAttribs * CheckedImplFile option * ModuleOrNamespaceType

/// Get the initial type checking state for a set of inputs

val GetInitialTcState: range * string * TcConfig * TcGlobals * TcImports * TcEnv * OpenDeclaration list -> TcState

/// Returns partial type check result for skipped implementation files.

val SkippedImplFilePlaceholder:

tcConfig: TcConfig * tcImports: TcImports * tcGlobals: TcGlobals * tcState: TcState * input: ParsedInput ->

((TcEnv * TopAttribs * CheckedImplFile option * ModuleOrNamespaceType) * TcState) option

/// Check one input, returned as an Eventually computation

val CheckOneInput:

checkForErrors: (unit -> bool) *

tcConfig: TcConfig *

tcImports: TcImports *

tcGlobals: TcGlobals *

prefixPathOpt: LongIdent option *

tcSink: TcResultsSink *

tcState: TcState *

input: ParsedInput ->

Cancellable<(TcEnv * TopAttribs * CheckedImplFile option * ModuleOrNamespaceType) * TcState>

val CheckOneInputWithCallback:

node: NodeToTypeCheck ->

checkForErrors: (unit -> bool) *

tcConfig: TcConfig *

tcImports: TcImports *

tcGlobals: TcGlobals *

prefixPathOpt: LongIdent option *

tcSink: TcResultsSink *

tcState: TcState *

input: ParsedInput *

_skipImplIfSigExists: bool ->

Cancellable<Finisher<NodeToTypeCheck, TcState, PartialResult>>

val AddCheckResultsToTcState:

tcGlobals: TcGlobals *

amap: Import.ImportMap *

hadSig: bool *

prefixPathOpt: LongIdent option *

tcSink: TcResultsSink *

tcImplEnv: TcEnv *

qualNameOfFile: QualifiedNameOfFile *

implFileSigType: ModuleOrNamespaceType ->

tcState: TcState ->

ModuleOrNamespaceType * TcState

val AddSignatureResultToTcImplEnv:

tcImports: TcImports *

tcGlobals: TcGlobals *

prefixPathOpt: LongIdent option *

tcSink: TcResultsSink *

tcState: TcState *

input: ParsedInput ->

(TcState -> PartialResult * TcState)

val TransformDependencyGraph: graph: Graph<FileIndex> * filePairs: FilePairMap -> Graph<NodeToTypeCheck>

/// Finish the checking of multiple inputs

val CheckMultipleInputsFinish:

(TcEnv * TopAttribs * 'T option * 'U) list * TcState -> (TcEnv * TopAttribs * 'T list * 'U list) * TcState

/// Finish the checking of a closed set of inputs

val CheckClosedInputSetFinish: CheckedImplFile list * TcState -> TcState * CheckedImplFile list * ModuleOrNamespace

/// Check a closed set of inputs

val CheckClosedInputSet:

ctok: CompilationThreadToken *

checkForErrors: (unit -> bool) *

tcConfig: TcConfig *

tcImports: TcImports *

tcGlobals: TcGlobals *

prefixPathOpt: LongIdent option *

tcState: TcState *

eagerFormat: (PhasedDiagnostic -> PhasedDiagnostic) *

inputs: ParsedInput list ->

TcState * TopAttribs * CheckedImplFile list * TcEnv

/// Check a single input and finish the checking

val CheckOneInputAndFinish:

checkForErrors: (unit -> bool) *

tcConfig: TcConfig *

tcImports: TcImports *

tcGlobals: TcGlobals *

prefixPathOpt: LongIdent option *

tcSink: TcResultsSink *

tcState: TcState *

input: ParsedInput ->

Cancellable<(TcEnv * TopAttribs * CheckedImplFile list * ModuleOrNamespaceType list) * TcState>