anchor.diff:  
           {   Condition            = XElem.getAttributeValue Constants.Condition xelem 
               DebugSymbols         = elemmap Constants.DebugSymbols Boolean.Parse
  -            DebugType            = elem    Constants.DebugType
  +            DebugType            = elemmap Constants.DebugType DebugType.Parse
               Optimize             = elemmap Constants.Optimize Boolean.Parse
               Tailcalls            = elemmap Constants.Tailcalls Boolean.Parse
               OutputPath           = elem    Constants.OutputPath
               CompilationConstants = elemmap Constants.CompilationConstants split
               WarningLevel         = elemmap Constants.WarningLevel (Int32.Parse>>WarningLevel)
               PlatformTarget       = elemmap Constants.PlatformTarget PlatformType.Parse
  -            Documentationfile    = elem    Constants.Documentationfile
  +            Documentationfile    = elem    Constants.DocumentationFile
               Prefer32Bit          = elemmap Constants.Prefer32Bit Boolean.Parse
               OtherFlags           = elemmap Constants.OtherFlags split
           }
  
positive.code: //         let filesNew = seq {yield! filesBefore; yield fileToMove; yield! filesAfter } |> Seq.toList
  //         { proj with SourceFiles = filesNew }
  
      let parse content =
          let xdoc = (XDocument.Parse content).Root
          let itemGroups = XElem.descendantsNamed Constants.ItemGroup xdoc
  
          let projectSettingsSqs =
              XElem.descendantsNamed Constants.PropertyGroup xdoc
              #if INTERACTIVE
              |> Seq.map (fun x -> printfn "%A" x ; x)
              #endif
              |> Seq.filter (fun pg -> not ^ XElem.hasAttribute Constants.Condition pg)
          
          #if INTERACTIVE
          projectSettingsSqs |> Seq.iter (printfn "%A") 
          #endif
  
          let projectSettings = projectSettingsSqs |> Seq.head |> ProjectSettings.fromXElem
  
      //    let buildConfigs =
      //        XElem.descendantsNamed "PropertyGroup" xdoc
      //        |> Seq.filter (fun pg -> XElem.hasAttribute "Condition" pg)
  
          let projectReferences =
              XElem.descendantsNamed Constants.ProjectReference xdoc
              |> Seq.map ProjectReference.fromXElem
  
          let filterItems name =
              itemGroups |> Seq.collect ^ XElem.descendantsNamed name
  
          let references =
              filterItems Constants.Reference
              |> Seq.filter  (not << XElem.hasElement Constants.Paket) // we only manage references paket isn't already managing
              |> Seq.map Reference.fromXElem
  
          let srcTree =
              itemGroups
              |> Seq.collect (fun itemgroup ->
                  XElem.descendants itemgroup
                  |> Seq.filter (fun x -> isSrcFile x.Name.LocalName))
              |> Seq.map SourceFile.fromXElem
              |> Seq.toList |> SourceTree
  
          let proj =
              {   ToolsVersion      = XElem.getAttributeValue Constants.ToolsVersion xdoc 
                  DefaultTargets    = [XElem.getAttributeValue Constants.DefaultTargets xdoc ]
                  References        = references |> List.ofSeq
                  Settings          = projectSettings
                  SourceFiles       = srcTree 
                  ProjectReferences = projectReferences |> List.ofSeq
                  BuildConfigs      = []
              }
  
          proj
  
      let load path =
          let content = System.IO.File.ReadAllText path
  //        #if INTERACTIVE
  //        printfn "%A" content
  //        #endif
          parse content
  
  // A small abstraction over MSBuild project files.
  type ProjectFile (projectFileName:string, documentContent:string) =
  
negative.code: //        
  
  [<AutoOpen>]
  module internal PathHelpers =
  
      let normalizeFileName (fileName : string) = 
          let file = fileName.Replace(@"\", "/").TrimEnd(Path.DirectorySeparatorChar).ToLower()   
  