anchor.diff:              with e ->
                   tcConfigB.RemoveReferencedAssemblyByPath(m,path)
                   reraise()
  -        let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) istate.optEnv ccuinfos
  -        istate.ilxGenerator.AddExternalCcus (ccuinfos |> List.map (fun ccuinfo -> ccuinfo.FSharpViewOfMetadata)) 
           resolutions,
  -        { istate with tcState = tcState.NextStateAfterIncrementalFragment(tcEnv); optEnv = optEnv }
  +        { addCcusToIncrementalEnv istate ccuinfos with tcState = tcState.NextStateAfterIncrementalFragment(tcEnv) }
   
   
       member __.EvalDependencyManagerTextFragment (packageManager:IDependencyManagerProvider,m,path: string) =
  
positive.code:             if PrettyNaming.IsCompilerGeneratedName name then
                  invalidArg "name" (FSComp.SR.lexhlpIdentifiersContainingAtSymbolReserved() |> snd)
  
              let istate, ty = this.ImportReflectionType(ctok, istate, value.GetType())
              let amap = istate.tcImports.GetImportMap()
  
              let i = nextFragmentId()
  
negative.code: 
          { istate with boundValues = boundValues }, Completed itValue
  
      let addCcusToIncrementalEnv istate ccuinfos =
          let optEnv = List.fold (AddExternalCcuToOptimizationEnv tcGlobals) istate.optEnv ccuinfos
          istate.ilxGenerator.AddExternalCcus (ccuinfos |> List.map (fun ccuinfo -> ccuinfo.FSharpViewOfMetadata))
          { istate with optEnv = optEnv }
  
      let importReflectionType istate reflectionTy =
          let tcImports = istate.tcImports
          let tcGlobals = istate.tcGlobals
          let amap = tcImports.GetImportMap()
  
          let prevCcuinfos = tcImports.GetImportedAssemblies()
          
          let rec import ccuinfos (ilTy: ILType) =
              let ccuinfos, tinst =
                  (ilTy.GenericArgs, (ccuinfos, []))
                  ||> List.foldBack (fun ilGenericArgTy (ccuInfos, tinst) ->
                      let ccuinfos2, ty = import ccuInfos ilGenericArgTy
                      (ccuinfos2 @ ccuinfos, ty :: tinst))
  
              let ty = Import.ImportILType amap range0 tinst ilTy
              let ccuinfos =
                  match tryTcrefOfAppTy tcGlobals ty with
                  | ValueSome tcref ->
                      match tcref.CompilationPath.ILScopeRef with
                      | ILScopeRef.Assembly aref ->
                          (tcImports.GetImportedAssemblies() |> List.find (fun x -> x.FSharpViewOfMetadata.AssemblyName = aref.Name)) :: ccuinfos
                      | _ ->
                          ccuinfos
                  | _ ->
                      ccuinfos
              ccuinfos, ty
          
          let ilTy = convertReflectionTypeToILType reflectionTy
  
          if not (Import.CanImportILType amap range0 ilTy) then
              invalidOp (sprintf "Unable to import type, %A." reflectionTy)
  
          let ccuinfos, ty = import [] ilTy
          let ccuinfos = 
              ccuinfos 
              |> List.distinctBy (fun x -> x.FSharpViewOfMetadata.AssemblyName)
              |> List.filter (fun asm1 -> not (prevCcuinfos |> List.exists (fun asm2 -> asm2.FSharpViewOfMetadata.AssemblyName = asm1.FSharpViewOfMetadata.AssemblyName)))
          // After we have successfully imported the type, then we can add newly resolved ccus to the env.
          addCcusToIncrementalEnv istate ccuinfos, ty
  
      member __.DynamicAssemblyName = assemblyName
  
      member __.DynamicAssembly = (assemblyBuilder :> Assembly)
  