anchor.diff:  open FSharp.Compiler.AbstractIL.Internal 
   open FSharp.Compiler.AbstractIL.Internal.Library 
   open FSharp.Compiler.AbstractIL.Diagnostics
  +
   open FSharp.Compiler.IlxGen
  -
   open FSharp.Compiler.AccessibilityLogic
   open FSharp.Compiler.AttributeChecking
   open FSharp.Compiler.Ast
  
positive.code: 
                // Glue all this stuff into ilxMainModule 
                let ilxMainModule, rewriteExternalRefsToLocalRefs = 
                    StaticLinkILModules (tcConfig, ilGlobals, ilxMainModule, dependentILModules @ providerGeneratedILModules)
                
                // Rewrite type and assembly references
                let ilxMainModule =
                    let isMscorlib = ilGlobals.primaryAssemblyName = PrimaryAssembly.Mscorlib.Name
  
negative.code: //----------------------------------------------------------------------------
  
  /// Optional static linking of all DLLs that depend on the F# Library, plus other specified DLLs
  module StaticLinker =
  
      open FSharp.Compiler.AbstractIL
  
      // Handles TypeForwarding for the generated IL model
      type TypeForwarding (tcImports: TcImports) =
  
          // Make a dictionary of ccus passed to the compiler will be looked up by qualified assembly name
          let ccuThunksQualifiedName =
              tcImports.GetCcusInDeclOrder()
              |> List.filter(fun ccuThunk -> ccuThunk.QualifiedName |> Option.isSome)
              |> List.map(fun ccuThunk -> ccuThunk.QualifiedName |> Option.defaultValue "Assembly Name Not Passed", ccuThunk)
              |> dict
  
          // If we can't type forward using exact assembly match, we need to rely on the loader (Policy, Configuration or the coreclr load heuristics), so use try simple name
          let ccuThunksSimpleName =
              tcImports.GetCcusInDeclOrder()
              |> List.filter(fun ccuThunk -> not (String.IsNullOrEmpty(ccuThunk.AssemblyName)))
              |> List.map(fun ccuThunk -> ccuThunk.AssemblyName, ccuThunk)
              |> dict
  
          let followTypeForwardForILTypeRef (tref:ILTypeRef) =
              let typename =
                  let parts =  tref.FullName.Split([|'.'|])
                  match parts.Length with
                  | 0 -> None
                  | 1 -> Some (Array.empty<string>, parts.[0])
                  | n -> Some (parts.[0..n-2], parts.[n-1])
  
              let  scoref = tref.Scope
              match scoref with
              | ILScopeRef.Assembly scope ->
                  match ccuThunksQualifiedName.TryGetValue(scope.QualifiedName) with
                  | true, ccu ->
                      match typename with
                      | Some (parts, name) ->
                          let forwarded = ccu.TryForward(parts, name)
                          let result =
                              match forwarded with
                              | Some fwd -> fwd.CompilationPath.ILScopeRef
                              | None -> scoref
                          result
                      | None -> scoref
                  | false, _ ->
                      // Couldn't find an assembly with the version so try using a simple name
                      match ccuThunksSimpleName.TryGetValue(scope.Name) with
                      | true, ccu ->
                          match typename with
                          | Some (parts, name) ->
                              let forwarded = ccu.TryForward(parts, name)
                              let result =
                                  match forwarded with
                                  | Some fwd -> fwd.CompilationPath.ILScopeRef
                                  | None -> scoref
                              result
                          | None -> scoref
                      | false, _ -> scoref
              | _ -> scoref
  
          let typeForwardILTypeRef (tref: ILTypeRef) =
              let scoref1 = tref.Scope
              let scoref2 = followTypeForwardForILTypeRef tref
              if scoref1 === scoref2 then tref
              else ILTypeRef.Create (scoref2, tref.Enclosing, tref.Name)
  
          member __.TypeForwardILTypeRef tref = typeForwardILTypeRef tref
  
      let debugStaticLinking = condition "FSHARP_DEBUG_STATIC_LINKING"
  
      let StaticLinkILModules (tcConfig:TcConfig, ilGlobals, tcImports, ilxMainModule, dependentILModules: (CcuThunk option * ILModuleDef) list) = 
          if isNil dependentILModules then 
              ilxMainModule, (fun x -> x) 
          else
              let typeForwarding = new TypeForwarding(tcImports)
  
              // Check no dependent assemblies use quotations   
              let dependentCcuUsingQuotations = dependentILModules |> List.tryPick (function (Some ccu, _) when ccu.UsesFSharp20PlusQuotations -> Some ccu | _ -> None)   
  