open Internal.Utilities

open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library

let maxSuggestions = 5

let minThresholdForSuggestions = 0.7

let highConfidenceThreshold = 0.85

let minStringLengthForThreshold = 3

let IsInEditDistanceProximity idText suggestion =

let editDistance = EditDistance.CalcEditDistance(idText, suggestion)

let threshold =

match idText.Length with

| x when x < 5 -> 1

| x when x < 7 -> 2

| x -> x / 4 + 1

editDistance <= threshold

let FilterPredictions (idText:string) (suggestionF:ErrorLogger.Suggestions) =

let uppercaseText = idText.ToUpperInvariant()

let allSuggestions = suggestionF()

let demangle (nm:string) =

if nm.StartsWithOrdinal("( ") && nm.EndsWithOrdinal(" )") then

let cleanName = nm.[2..nm.Length - 3]

cleanName

else nm

/// Returns `true` if given string is an operator display name, e.g. ( |>> )

let IsOperatorName (name: string) =

if not (name.StartsWithOrdinal("( ") && name.EndsWithOrdinal(" )")) then

false

else

let name = name.[2..name.Length - 3]

name |> Seq.forall (fun c -> c <> ' ')

if allSuggestions.Contains idText then [] else // some other parsing error occurred

allSuggestions

|> Seq.choose (fun suggestion ->

// Because beginning a name with _ is used both to indicate an unused

// value as well as to formally squelch the associated compiler

// error/warning (FS1182), we remove such names from the suggestions,

// both to prevent accidental usages as well as to encourage good taste

if IsOperatorName suggestion || suggestion.StartsWithOrdinal("_") then None else

let suggestion:string = demangle suggestion

let suggestedText = suggestion.ToUpperInvariant()

let similarity = EditDistance.JaroWinklerDistance uppercaseText suggestedText

if similarity >= highConfidenceThreshold || suggestion.EndsWithOrdinal("." + idText) then

Some(similarity, suggestion)

elif similarity < minThresholdForSuggestions && suggestedText.Length > minStringLengthForThreshold then

None

elif IsInEditDistanceProximity uppercaseText suggestedText then

Some(similarity, suggestion)

else

None)

|> Seq.sortByDescending fst

|> Seq.mapi (fun i x -> i, x)

|> Seq.takeWhile (fun (i, _) -> i < maxSuggestions)

|> Seq.map snd

|> Seq.toList

let FormatPredictions normalizeF (predictions: (float * string) list) =

match predictions with

| [] -> System.String.Empty

| _ ->

let suggestions =

predictions

|> List.map (snd >> normalizeF)

|> List.map (sprintf "%s %s" System.Environment.NewLine)

|> String.concat ""

" " + FSComp.SR.undefinedNameSuggestionsIntro() + suggestions