anchor.diff:                                  AtStartOfIdentifier(pos+1,""::current,throwAwayNext)                            
                           else AtStartOfIdentifier(pos+1,[],throwAwayNext)
               let plid, residue = AtStartOfIdentifier(0,[],false)
  -            let plid = (List.rev plid)
  +            let plid = List.rev plid
               match plid with
  -            | s::_rest when s.Length > 0 && Char.IsDigit(s.[0]) -> ([],"")  // "2.0" is not a longId (this might not be right for ``2.0`` but good enough for common case)
  +            | s::_rest when s.Length > 0 && Char.IsDigit(s.[0]) -> defaultName  // "2.0" is not a longId (this might not be right for ``2.0`` but good enough for common case)
               | _ -> plid, residue
  -
  -
       
       let TokenNameEquals (tokenInfo : FSharpTokenInfo) token2 = 
  -        String.Compare(tokenInfo .TokenName, token2, StringComparison.OrdinalIgnoreCase)=0  
  +        String.Compare(tokenInfo .TokenName, token2, StringComparison.OrdinalIgnoreCase) = 0  
       
       // The prefix of the sequence of token names to look for in TestMemberOrOverrideDeclaration, in reverse order
       let private expected = [ [|"dot"|]; [|"ident"|]; [|"member"; "override"|] ]
  
positive.code:             else 
                  directResult
  
      /// Get the partial long name of the identifier to the left of index.
      let GetPartialLongName(line:string,index) =
          if isNull line then [],""
          elif index < 0 then [],""
          elif index >= line.Length then [],""
          else
              let IsIdentifierPartCharacter pos = IsIdentifierPartCharacter line.[pos]
              let IsLongIdentifierPartCharacter pos = IsLongIdentifierPartCharacter line.[pos]
  
negative.code:                     let l = searchLeft p
                      let r = searchRight p
                      let ident = s.Substring (l, r - l + 1)
                      if ident.IndexOf('|') <> -1 && not(isValidActivePatternName(ident)) then None else
                          let pos = r + magicalAdjustmentConstant 
                          Some(ident, pos, false)
                      )
  
      let GetCompleteIdentifierIsland (tolerateJustAfter:bool) (s : string) (p : int) : (string*int*bool) option =
          if String.IsNullOrEmpty s then None
          else     
              let directResult = GetCompleteIdentifierIslandImpl s p
              if tolerateJustAfter && directResult = None then 
  