anchor.diff:  
         abstractExprInfo ivalue
   
  -//-------------------------------------------------------------------------
  -// Remap optimization information, e.g. to use public stable references so we can pickle it
  -// to disk.
  -//------------------------------------------------------------------------- 
  +/// Remap optimization information, e.g. to use public stable references so we can pickle it
  +/// to disk.
   let RemapOptimizationInfo g tmenv =
   
       let rec remapExprInfo ivalue = 
  
positive.code:              Zset.exists hiddenRecdField fvs.FreeRecdFields        ||
               Zset.exists hiddenUnionCase fvs.FreeUnionCases ) ->
                  UnknownValue
          // Check for escape in constant 
          | ConstValue(_, ty) when 
              (let ftyvs = freeInType CollectAll ty
               (isAssemblyBoundary && not (freeTyvarsAllPublic ftyvs)) || 
               Zset.exists hiddenTycon ftyvs.FreeTycons) ->
                  UnknownValue
          | TupleValue vinfos         -> 
              TupleValue (Array.map abstractExprInfo vinfos)
          | RecdValue (tcref, vinfos)  -> 
              if hiddenTyconRepr tcref.Deref || Array.exists (tcref.MakeNestedRecdFieldRef >> hiddenRecdField) tcref.AllFieldsArray
              then UnknownValue 
              else RecdValue (tcref, Array.map abstractExprInfo vinfos)
          | UnionCaseValue(ucref, vinfos) -> 
              let tcref = ucref.TyconRef
              if hiddenTyconRepr ucref.Tycon || tcref.UnionCasesArray |> Array.exists (tcref.MakeNestedUnionCaseRef >> hiddenUnionCase) 
              then UnknownValue 
              else UnionCaseValue (ucref, Array.map abstractExprInfo vinfos)
          | SizeValue(_vdepth, vinfo)   -> MakeSizedValueInfo (abstractExprInfo vinfo)
          | UnknownValue  
          | ConstExprValue _   
          | CurriedLambdaValue _ 
          | ConstValue _  -> ivalue
      and abstractValInfo v = 
          { ValExprInfo=abstractExprInfo v.ValExprInfo 
            ValMakesNoCriticalTailcalls=v.ValMakesNoCriticalTailcalls }
      and abstractModulInfo ss =
           { ModuleOrNamespaceInfos = NameMap.map abstractLazyModulInfo ss.ModuleOrNamespaceInfos
             ValInfos = 
                 ValInfos(ss.ValInfos.Entries 
                           |> Seq.filter (fun (vref, _) -> not (hiddenVal vref.Deref))
                           |> Seq.map (fun (vref, e) -> check (* "its implementation uses a binding hidden by a signature" m *)  vref (abstractValInfo e) )) } 
      and abstractLazyModulInfo (ss:LazyModuleInfo) = 
            ss.Force() |> abstractModulInfo |> notlazy
  
  
negative.code:         else
              GetInfoForNonLocalVal cenv env vref
  
      check vref res |> ignore
      res
  
  //-------------------------------------------------------------------------
  