anchor.diff:                                  |> Option.map fst
   
                               match groupName with
  -                            | None -> np.Name,specificVersionRequirement
  +                            | None -> np,specificVersionRequirement,noFrameworkRestriction
                               | Some groupName -> 
                                   let group = lockFile.GetGroup groupName
   
  -                                let lockedVersion = 
  +                                let lockedVersion, fwRestriction = 
                                       match Map.tryFind np.Name group.Resolution with
  -                                    | Some resolvedPackage -> VersionRequirement(GreaterThan resolvedPackage.Version, getPreReleaseStatus resolvedPackage.Version)
  -                                    | None -> specificVersionRequirement
  -
  -                                np.Name,lockedVersion
  +                                    | Some resolvedPackage -> VersionRequirement(GreaterThan resolvedPackage.Version, getPreReleaseStatus resolvedPackage.Version), resolvedPackage.Settings.FrameworkRestrictions
  +                                    | None -> specificVersionRequirement, noFrameworkRestriction
  +
  +                                np,lockedVersion,fwRestriction
                           else
  -                            np.Name,specificVersionRequirement
  +                            np,specificVersionRequirement,noFrameworkRestriction
                   | Some groupName ->
                       let dependencyVersionRequirement =
                           if not lockDependencies then
  
positive.code:                                                 | OverrideAll v -> 
                                                      if v <> resolvedPackage.Version then
                                                          failwithf "Versions in %s and %s are not identical for package %O." lockFile.FileName dependenciesFile.FileName np.Name
                                                      Some(VersionRequirement(Specific resolvedPackage.Version,pre))
                                                  | Specific v -> 
                                                      if v <> resolvedPackage.Version then
                                                          failwithf "Versions in %s and %s are not identical for package %O." lockFile.FileName dependenciesFile.FileName np.Name
                                                      Some(VersionRequirement(Specific resolvedPackage.Version,pre))
                                                  | Maximum v ->
                                                      if v = resolvedPackage.Version then
                                                          Some(VersionRequirement(Specific resolvedPackage.Version,pre))
                                                      else
                                                          Some(VersionRequirement(VersionRange.Range(VersionRangeBound.Including,resolvedPackage.Version,v,VersionRangeBound.Including),pre))
                                                  | Range(_,_,v2,ub) ->
                                                      Some(VersionRequirement(VersionRange.Range(VersionRangeBound.Including,resolvedPackage.Version,v2,ub),pre))
                                                  | _ -> Some(VersionRequirement(Minimum resolvedPackage.Version,pre))
                                              | None -> Some requirement.VersionRequirement
                                      else
                                          Some requirement.VersionRequirement
                                  | None ->
                                      match lockFile.Groups |> Map.tryFind groupName with
                                      | None -> None
  
negative.code:                    match core.Version with
                     | Some v -> 
                         let versionConstraint = interprojectReferencesConstraint.CreateVersionRequirements v
                         let anyFw = FrameworkRestrictions.ExplicitRestriction (FrameworkRestriction.NoRestriction)
                         PackageName core.Id, VersionRequirement(versionConstraint, getPreReleaseStatus v), anyFw
                     | None -> failwithf "There was no version given for %s." evaluatedTemplate.FileName
                 | IncompleteTemplate -> 
                     failwithf "You cannot create a dependency on a template file (%s) with incomplete metadata." evaluatedTemplate.FileName)
  