anchor.diff:  
       member private tcImports.AttachDisposeAction action =
           CheckDisposed()
  -        disposeActions <- action :: disposeActions
  +        disposeActions.Add action
   
   #if !NO_EXTENSIONTYPING
       member private tcImports.AttachDisposeTypeProviderAction action =
           CheckDisposed()
  -        disposeTypeProviderActions <- action :: disposeTypeProviderActions
  +        disposeTypeProviderActions.Add action
   #endif
     
       // Note: the returned binary reader is associated with the tcImports, i.e. when the tcImports are closed 
  
positive.code:     let mutable dllTable: NameMap<ImportedBinary> = NameMap.empty
      let mutable ccuInfos: ImportedAssembly list = []
      let mutable ccuTable: NameMap<ImportedAssembly> = NameMap.empty
      let mutable disposeActions = []
      let mutable disposed = false
      let mutable ilGlobalsOpt = ilGlobalsOpt
      let mutable tcGlobals = None
  #if !NO_EXTENSIONTYPING
      let mutable disposeTypeProviderActions = []
      let mutable generatedTypeRoots = new System.Collections.Generic.Dictionary<ILTypeRef, int * ProviderGeneratedType>()
      let mutable tcImportsWeak = TcImportsWeakHack (WeakReference<_> this)
  #endif
      
      let CheckDisposed() =
          if disposed then assert false
  
      let dispose () =
          CheckDisposed()
          // disposing deliberately only closes this tcImports, not the ones up the chain 
          disposed <- true        
          if verbose then 
              dprintf "disposing of TcImports, %d binaries\n" disposeActions.Length
  #if !NO_EXTENSIONTYPING
          let actions = disposeTypeProviderActions
          disposeTypeProviderActions <- []
          if actions.Length > 0 then
              compilationThread.EnqueueWork (fun _ -> for action in actions do action())
  #endif
          let actions = disposeActions
          disposeActions <- []
          for action in actions do action()
  
      static let ccuHasType (ccu: CcuThunk) (nsname: string list) (tname: string) =
          let matchNameSpace (entityOpt: Entity option) n =
  
negative.code: // TcImports
  //--------------------------------------------------------------------------
  
  [<Sealed>]
  type TcImportsSafeDisposal
      (disposeActions: ResizeArray<unit -> unit>,
  #if !NO_EXTENSIONTYPING
       disposeTypeProviderActions: ResizeArray<unit -> unit>,
  #endif
       compilationThread: ICompilationThread) =
  
      let mutable isDisposed = false
  
      let dispose () =
          // disposing deliberately only closes this tcImports, not the ones up the chain 
          isDisposed <- true        
          if verbose then 
              dprintf "disposing of TcImports, %d binaries\n" disposeActions.Count
  #if !NO_EXTENSIONTYPING
          let actions = disposeTypeProviderActions
          if actions.Count > 0 then
              compilationThread.EnqueueWork (fun _ -> for action in actions do action())
  #endif
          for action in disposeActions do action()
  
      override _.Finalize() =
          dispose ()
  
      interface IDisposable with
  
          member this.Dispose()  =
              if not isDisposed then
                  GC.SuppressFinalize this
                  dispose ()
  
  #if !NO_EXTENSIONTYPING
  // These are hacks in order to allow TcImports to be held as a weak reference inside a type provider.
  // The reason is due to older type providers compiled using an older TypeProviderSDK, that SDK used reflection on fields and properties to determine the contract.
  