#if STRONG_NAME_FSHARP_COMPILER_WITH_TEST_KEY

memberx.embedResources= data.embedResources

memberx.globalWarnAsError= data.globalWarnAsError

memberx.globalWarnLevel= data.globalWarnLevel

memberx.specificWarnOff= data.specificWarnOff

memberx.specificWarnOn= data.specificWarnOn

memberx.specificWarnOff= data.specificWarnOff

memberx.specificWarnOn= data.specificWarnOn

memberx.specificWarnAsError= data.specificWarnAsError

memberx.specificWarnAsWarn= data.specificWarnAsWarn

memberx.mlCompatibility= data.mlCompatibility

letrest= attempt specs

processArg rest

letresult= processArg args

result

processArg args

internalnew: cenv: Impl.cenv* mimpl: TypedImplFile-> FSharpImplementationFileContents

TcSymbolUses:TcSymbolUses list

TcDependencyFiles:string list

TopAttribs:TopAttribs option

TimeStamp:System.DateTime}

TimeStamp:System.DateTime

ImplementationFiles:TypedImplFile list}

{ TcState= tcAcc.tcState

TcSymbolUses= tcAcc.tcSymbolUses

TcDependencyFiles= tcAcc.tcDependencyFiles

TopAttribs= tcAcc.topAttribs

TimeStamp= timestamp}

TimeStamp= timestamp

ImplementationFiles= tcAcc.typedImplFiles}

TopAttribs:TypeChecker.TopAttribs option

TimeStamp:DateTime}

TimeStamp:DateTime

ImplementationFiles:TypedImplFile list}

loadClosure: LoadClosure option,

reactorOps: IReactorOperations,

checkAlive:(unit-> bool),

textSnapshotInfo:obj option)=

textSnapshotInfo:obj option,

implementationFiles: TypedImplFile list)=

lettextSnapshotInfo= defaultArg textSnapshotInfonull

member__.ThisCcu= thisCcu

member__.ImplementationFiles= implementationFiles

override__.ToString()="TypeCheckInfo("+ mainInputFileName+")"

leterrors= errHandler.CollectedDiagnostics

match tcEnvAtEndOptwith

| Some(tcEnvAtEnd,_typedImplFiles, tcState)->

| Some(tcEnvAtEnd,typedImplFiles, tcState)->

TypeCheckInfo(tcConfig, tcGlobals,

tcState.PartialAssemblySignature,

loadClosure,

reactorOps,

checkAlive,

textSnapshotInfo)

textSnapshotInfo,

typedImplFiles)

return errors, TypeCheckAborted.No scope

| None->

return errors, TypeCheckAborted.Yes

FSharpAssemblySignature(tcGlobals, thisCcu, tcImports, topAttribs, ccuSig)

ifnot keepAssemblyContentsthen invalidOp"The 'keepAssemblyContents' flag must be set totru on the FSharpChecker in order to access the checked contents of assemblies"

ifnot keepAssemblyContentsthen invalidOp"The 'keepAssemblyContents' flag must be set totrue on the FSharpChecker in order to access the checked contents of assemblies"

let(tcGlobals,tcImports,thisCcu,_ccuSig,_tcSymbolUses,_topAttribs,_tcAssemblyData,_ilAssemRef,_ad,tcAssemblyExpr,_dependencyFiles)= getDetails()

match tcAssemblyExprwith

let mutabledetails=match scopeOptXwith None-> None| Some scopeX-> Some(scopeX, builderX, reactorOpsX)

RequireCompilationThread ctok

scope.IsRelativeNameResolvable(pos, plid, item))

ifnot keepAssemblyContentsthen invalidOp"The 'keepAssemblyContents' flag must be set to true on the FSharpChecker in order to access the checked contents of assemblies"

scopeOptX

|> Option.map(fun scope->

letcenv= Impl.cenv(scope.TcGlobals, scope.ThisCcu, scope.TcImports)

[for mimplin scope.ImplementationFiles-> FSharpImplementationFileContents(cenv, mimpl)])

overrideinfo.ToString()="FSharpCheckFileResults("+ filename+")"

FSharpCheckFileResults(filename, Array.ofList creationErrors, None,[], None, reactorOps)

FSharpCheckFileResults(filename, Array.ofList creationErrors, None,[], None, reactorOps, keepAssemblyContents)

yield! tcErrors|]

FSharpCheckFileResults(filename, errors, Some scope, dependencyFiles, Some builder, reactorOps)

FSharpCheckFileResults(filename, errors, Some scope, dependencyFiles, Some builder, reactorOps, keepAssemblyContents)

match tcFileResultwith

List.last tcProj.TcResolutions,

List.last tcProj.TcSymbolUses,

tcProj.TcEnvAtEnd.NameEnv,

loadClosure, reactorOps,(fun()-> builder.IsAlive), None)

loadClosure, reactorOps,(fun()-> builder.IsAlive), None,

tcProj.ImplementationFiles)

lettypedResults= MakeCheckFileResults(filename, options, builder, scope, tcProj.TcDependencyFiles, creationErrors, parseResults.Errors, tcErrors)

return(parseResults, typedResults)

match tcFileResultwith

| Parser.TypeCheckAborted.No scope->

leterrors=[|yield! parseErrors;yield! tcErrors|]

lettypeCheckResults= FSharpCheckFileResults(filename, errors, Some scope, dependencyFiles, None, reactorOps)

lettypeCheckResults= FSharpCheckFileResults(filename, errors, Some scope, dependencyFiles, None, reactorOps,false)

letprojectResults= FSharpCheckProjectResults(filename, keepAssemblyContents, errors, Some(tcGlobals, tcImports, scope.ThisCcu, scope.CcuSig,[scope.ScopeSymbolUses], None, None, mkSimpleAssRef"stdin", tcState.TcEnvFromImpls.AccessRights, None, dependencyFiles), reactorOps)

parseResults, typeCheckResults, projectResults

///<param name="userOpName">An optional string usedfor tracing compiler operations associatedwith this request.</param>

#if COMPILER_PUBLIC_API

[for ein checkResults1.Errors-> e.StartLineAlternate, e.EndLineAlternate, e.FileName]|> shouldEqual[(4,4, ProjectLineDirectives.fileName1)]

letfileName1= Path.ChangeExtension(Path.GetTempFileName(),".fs")

letbase2= Path.GetTempFileName()

letdllName= Path.ChangeExtension(base2,".dll")

letprojFileName= Path.ChangeExtension(base2,".fsproj")

File.WriteAllText(fileName1, fileSource1)

letfileNames=[fileName1]

letargs= mkProjectCommandLineArgs(dllName, fileNames)

letkeepAssemblyContentsChecker= FSharpChecker.Create(keepAssemblyContents=true)

letoptions= keepAssemblyContentsChecker.GetProjectOptionsFromCommandLineArgs(projFileName, args)

keepAssemblyContentsChecker.ParseAndCheckFileInProject(fileName1,0, fileSource1, options)|> Async.RunSynchronously

|_, FSharpCheckFileAnswer.Succeeded(res)-> res

|_-> failwithf"Parsing aborted unexpectedly..."

match fileCheckResults.ImplementationFileswith

| Some(implFile::_)->

match implFile.Declarations|> List.tryHeadwith

| Some(FSharpImplementationFileDeclaration.Entity(_, subDecls))-> subDecls

|_-> failwith"unexpected declaration"

| Some[]| None-> failwith"File check results does not contain any `ImplementationFile`s"

match declarations|> List.tryHeadwith

| Some(FSharpImplementationFileDeclaration.Entity(entity,[]))->

entity.DisplayName|> shouldEqual"A"

letmemberNames= entity.MembersFunctionsAndValues|> Seq.map(fun x-> x.DisplayName)|> Set.ofSeq

Assert.That(memberNames, Contains.Item"Value")

| Some decl-> failwithf"unexpected declaration%A" decl

| None-> failwith"declaration list is empty"