anchor.diff:  let mkSynId m s = Ident(s,m)
   let pathToSynLid m p = List.map (mkSynId m) p
   let mkSynIdGet m n = SynExpr.Ident(mkSynId m n)
  -let mkSynLidGet m path n = 
  +let mkSynLidGet m path n =
       let lid = pathToSynLid m path @ [mkSynId m n]
       let dots = List.replicate (lid.Length - 1) m
       SynExpr.LongIdent(false,LongIdentWithDots(lid,dots),None,m)
  -let mkSynIdGetWithAlt m id altInfo = 
  -    match altInfo with 
  +let mkSynIdGetWithAlt m id altInfo =
  +    match altInfo with
       | None -> SynExpr.Ident id
       | _ -> SynExpr.LongIdent(false,LongIdentWithDots([id],[]),altInfo,m)
   
  
positive.code:     // The let bindings are 'sticky' in that the inversion of the inlining would involve
      // replacing the entire expression with the original and not just the let bindings alone.
      | NoSequencePointAtStickyBinding
      // Given 'let v = e1 in e2', where this is a compiler generated binding, 
      // we are sometimes forced to generate a sequence point for the expression anyway based on its
      // overall range. If the let binding is given the flag below then it is asserting that
      // the binding has no interesting side effects and can be totally ignored and the range
      // of the inner expression is used instead
      | NoSequencePointAtInvisibleBinding
      
      // Don't drop sequence points when combining sequence points
      member x.Combine(y:SequencePointInfoForBinding) = 
          match x,y with 
          | SequencePointAtBinding _ as g, _  -> g
          | _, (SequencePointAtBinding _ as g)  -> g
          | _ -> x
  
  /// Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions
  type SeqExprOnly = 
      | SeqExprOnly of bool
  
  /// denotes location of the separator block + optional position of the semicolon (used for tooling support)
  
negative.code: 
  /// The syntactic elements associated with the "return" of a function or method. Some of this is
  /// mostly dummy information to make the return element look like an argument,
  /// the important thing is that (a) you can give a return type for the function or method, and
  /// (b) you can associate .NET attributes to return of a function or method and these get stored in .NET metadata.
  type SynReturnInfo = SynReturnInfo of (SynType * SynArgInfo) * range:range
  
  
  /// Operations related to the syntactic analysis of arguments of value, function and member definitions and signatures.
  