Skip to content

Commit 2f46006

Browse files
dsymedsyme
committed
Prettify syymbol types
1 parent 0f12b7e commit 2f46006

File tree

5 files changed

+182
-43
lines changed

5 files changed

+182
-43
lines changed

‎src/fsharp/TastOps.fs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2282,8 +2282,9 @@ module PrettyTypes = begin
22822282
let PrettifyTypes1 g x = PrettifyTypes g (fun f -> f) (fun f -> f) x
22832283
let PrettifyTypes2 g x = PrettifyTypes g (fun f -> foldPair (f,f)) (fun f -> mapPair (f,f)) x
22842284
let PrettifyTypesN g x = PrettifyTypes g List.fold List.map x
2285+
let PrettifyTypesNN g x = PrettifyTypes g (fun f -> List.fold (List.fold f)) List.mapSquared x
2286+
let PrettifyTypesNN1 g x = PrettifyTypes g (fun f -> foldPair (List.fold (List.fold f),f)) (fun f -> mapPair (List.mapSquared f,f)) x
22852287
let PrettifyTypesN1 g (x:UncurriedArgInfos * TType) = PrettifyTypes g (fun f -> foldPair (List.fold (fold1Of2 f), f)) (fun f -> mapPair (List.map (map1Of2 f),f)) x
2286-
let PrettifyTypesNN1 g x = PrettifyTypes g (fun f -> foldTriple (List.fold f, List.fold (fold1Of2 f),f)) (fun f -> mapTriple (List.map f, List.map (map1Of2 f), f)) x
22872288
let PrettifyTypesNM1 g (x:TType list * CurriedArgInfos * TType) = PrettifyTypes g (fun f -> foldTriple (List.fold f, List.fold (List.fold (fold1Of2 f)),f)) (fun f -> mapTriple (List.map f, List.mapSquared (map1Of2 f), f)) x
22882289

22892290
end

‎src/fsharp/TastOps.fsi‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -581,6 +581,8 @@ module PrettyTypes =
581581
val PrettifyTypes1 : TcGlobals -> TType -> TyparInst * TType * TyparConstraintsWithTypars
582582
val PrettifyTypes2 : TcGlobals -> TType * TType -> TyparInst * (TType * TType) * TyparConstraintsWithTypars
583583
val PrettifyTypesN : TcGlobals -> TType list -> TyparInst * TType list * TyparConstraintsWithTypars
584+
val PrettifyTypesNN : TcGlobals -> TType list list -> TyparInst * TType list list * TyparConstraintsWithTypars
585+
val PrettifyTypesNN1 : TcGlobals -> TType list list * TType -> TyparInst * (TType list list * TType) * TyparConstraintsWithTypars
584586
val PrettifyTypesN1 : TcGlobals -> UncurriedArgInfos * TType -> TyparInst * (UncurriedArgInfos * TType) * TyparConstraintsWithTypars
585587
val PrettifyTypesNM1 : TcGlobals -> TType list * CurriedArgInfos * TType -> TyparInst * (TType list * CurriedArgInfos * TType) * TyparConstraintsWithTypars
586588

‎src/fsharp/vs/Symbols.fs‎

Lines changed: 72 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -1197,8 +1197,7 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
11971197
let rty = m.GetFSharpReturnTy(cenv.amap,range0,m.FormalMethodInst)
11981198
let argtysl = m.GetParamTypes(cenv.amap,range0,m.FormalMethodInst)
11991199
mkIteratedFunTy (List.map (mkTupledTy cenv.g) argtysl) rty
1200-
| V v -> let _, typ, _ = PrettyTypes.PrettifyTypes1 cenv.g v.TauType
1201-
typ
1200+
| V v -> v.TauType
12021201
FSharpType(cenv, ty)
12031202

12041203
member __.HasGetterMethod =
@@ -1533,25 +1532,16 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
15331532
[ [ for (ParamData(isParamArrayArg,isOutArg,optArgInfo,nmOpt,_reflArgInfo,pty)) in p.GetParamDatas(cenv.amap,range0) do
15341533
// INCOMPLETENESS: Attribs is empty here, so we can't look at attributes for
15351534
// either .NET or F# parameters
1536-
let _, prettyTyp, _cxs = PrettyTypes.PrettifyTypes1 cenv.g pty
15371535
let argInfo : ArgReprInfo = { Name=nmOpt; Attribs= [] }
1538-
yield FSharpParameter(cenv,prettyTyp , argInfo, x.DeclarationLocationOpt, isParamArrayArg, isOutArg, optArgInfo.IsOptional) ]
1536+
yield FSharpParameter(cenv, pty, argInfo, x.DeclarationLocationOpt, isParamArrayArg, isOutArg, optArgInfo.IsOptional) ]
15391537
|> makeReadOnlyCollection ]
15401538
|> makeReadOnlyCollection
15411539

15421540
| E _ -> [] |> makeReadOnlyCollection
15431541
| M m ->
1544-
15451542
[ for argtys in m.GetParamDatas(cenv.amap,range0,m.FormalMethodInst) do
1546-
let _, prettyTyps, _cxs =
1547-
argtys
1548-
|> List.map (function ParamData(isParamArrayArg,isOutArg,optArgInfo,nmOpt,_reflArgInfo,pty) -> pty)
1549-
|> PrettyTypes.PrettifyTypesN cenv.g
1550-
let combined =
1551-
List.map2 (fun pty (ParamData(isParamArrayArg,isOutArg,optArgInfo,nmOpt,reflArgInfo,_pty)) ->
1552-
isParamArrayArg,isOutArg,optArgInfo,nmOpt,reflArgInfo,pty) prettyTyps argtys
15531543
yield
1554-
[ for (isParamArrayArg,isOutArg,optArgInfo,nmOpt,_reflArgInfo,pty) in combined do
1544+
[ for (ParamData(isParamArrayArg,isOutArg,optArgInfo,nmOpt,_reflArgInfo,pty)) in argtys do
15551545
// INCOMPLETENESS: Attribs is empty here, so we can't look at attributes for
15561546
// either .NET or F# parameters
15571547
let argInfo : ArgReprInfo = { Name=nmOpt; Attribs= [] }
@@ -1564,15 +1554,14 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
15641554
| None ->
15651555
let _, tau = v.TypeScheme
15661556
if isFunTy cenv.g tau then
1567-
let typeArguments, _typ = stripFunTy cenv.g tau
1568-
[ for typ in typeArguments do
1557+
let argtysl, _typ = stripFunTy cenv.g tau
1558+
[ for typ in argtysl do
15691559
let allArguments =
15701560
if isTupleTy cenv.g typ
15711561
then tryDestTupleTy cenv.g typ
15721562
else [typ]
1573-
let _, prettyTyps, _cxs = allArguments |> PrettyTypes.PrettifyTypesN cenv.g
15741563
yield
1575-
prettyTyps
1564+
allArguments
15761565
|> List.map (fun arg -> FSharpParameter(cenv, arg, { Name=None; Attribs= [] }, x.DeclarationLocationOpt, false, false, false))
15771566
|> makeReadOnlyCollection ]
15781567
|> makeReadOnlyCollection
@@ -1581,8 +1570,7 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
15811570
let tau = v.TauType
15821571
let argtysl,_ = GetTopTauTypeInFSharpForm cenv.g curriedArgInfos tau range0
15831572
let argtysl = if v.IsInstanceMember then argtysl.Tail else argtysl
1584-
let prettyArgtysl = argtysl |> List.map (fun a -> PrettyTypes.PrettifyTypesN1 cenv.g (a, tau))
1585-
[ for (_, (argtys,_),_cxs) in prettyArgtysl do
1573+
[ for argtys in argtysl do
15861574
yield
15871575
[ for argty, argInfo in argtys do
15881576
let isParamArrayArg = HasFSharpAttribute cenv.g cenv.g.attrib_ParamArrayAttribute argInfo.Attribs
@@ -1604,39 +1592,29 @@ and FSharpMemberOrFunctionOrValue(cenv, d:FSharpMemberOrValData, item) =
16041592
// For non-standard events, just use the delegate type as the ReturnParameter type
16051593
e.GetDelegateType(cenv.amap,range0)
16061594

1607-
let _, rty, _cxs = PrettyTypes.PrettifyTypes1 cenv.g rty
16081595
FSharpParameter(cenv, rty, retInfo, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
16091596

16101597
| P p ->
16111598
// INCOMPLETENESS: Attribs is empty here, so we can't look at return attributes for .NET or F# methods
16121599
let retInfo : ArgReprInfo = { Name=None; Attribs= [] }
16131600
let rty = p.GetPropertyType(cenv.amap,range0)
1614-
let _, rty, _cxs = PrettyTypes.PrettifyTypes1 cenv.g rty
16151601
FSharpParameter(cenv, rty, retInfo, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
16161602
| M m ->
16171603
// INCOMPLETENESS: Attribs is empty here, so we can't look at return attributes for .NET or F# methods
16181604
let retInfo : ArgReprInfo = { Name=None; Attribs= [] }
16191605
let rty = m.GetFSharpReturnTy(cenv.amap,range0,m.FormalMethodInst)
1620-
let _, rty, _cxs = PrettyTypes.PrettifyTypes1 cenv.g rty
16211606
FSharpParameter(cenv, rty, retInfo, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
16221607
| V v ->
16231608
match v.ValReprInfo with
16241609
| None ->
16251610
let _, tau = v.TypeScheme
1626-
if isFunTy cenv.g tau then
1627-
let typeArguments, rty = stripFunTy cenv.g tau
1628-
let empty : ArgReprInfo = { Name=None; Attribs= [] }
1629-
let uncurriedArgInfos = typeArguments |> List.map (fun t -> (t, empty ) )
1630-
let _, (_argtys, rty), _csx = PrettyTypes.PrettifyTypesN1 cenv.g (uncurriedArgInfos, rty)
1631-
FSharpParameter(cenv, rty, empty, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
1632-
else
1633-
failwith "not a module let binding or member"
1634-
| Some (ValReprInfo(typars,argInfos,retInfo)) ->
1635-
1611+
let _argtysl, rty = stripFunTy cenv.g tau
1612+
let empty : ArgReprInfo = { Name=None; Attribs= [] }
1613+
FSharpParameter(cenv, rty, empty, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
1614+
| Some (ValReprInfo(_typars,argInfos,retInfo)) ->
16361615
let tau = v.TauType
1637-
let c,rty = GetTopTauTypeInFSharpForm cenv.g argInfos tau range0
1638-
let (typar, (_types, _, prettyReturn), _cxs) = PrettyTypes.PrettifyTypesNM1 cenv.g ([tau], c, rty)
1639-
FSharpParameter(cenv, prettyReturn, retInfo, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
1616+
let _c,rty = GetTopTauTypeInFSharpForm cenv.g argInfos tau range0
1617+
FSharpParameter(cenv, rty, retInfo, x.DeclarationLocationOpt, isParamArrayArg=false, isOutArg=false, isOptionalArg=false)
16401618

16411619

16421620
member __.Attributes =
@@ -1850,27 +1828,77 @@ and FSharpType(cenv, typ:TType) =
18501828
GetSuperTypeOfType cenv.g cenv.amap range0 typ
18511829
|> Option.map (fun ty -> FSharpType(cenv, ty))
18521830

1853-
member x.Instantiate(tys:(FSharpGenericParameter * FSharpType) list) =
1854-
let typI = instType (tys |> List.map (fun (tyv,typ) -> tyv.V, typ.Typ)) typ
1831+
member x.Instantiate(instantiation:(FSharpGenericParameter * FSharpType) list) =
1832+
let typI = instType (instantiation |> List.map (fun (tyv,typ) -> tyv.V, typ.V)) typ
18551833
FSharpType(cenv, typI)
18561834

1857-
member private x.Typ = typ
1835+
member private x.V = typ
1836+
member private x.cenv = cenv
1837+
1838+
member private typ.AdjustType(t) =
1839+
FSharpType(typ.cenv, t)
18581840

18591841
override x.Equals(other : obj) =
18601842
box x === other ||
18611843
match other with
1862-
| :? FSharpType as t -> typeEquiv cenv.g typ t.Typ
1844+
| :? FSharpType as t -> typeEquiv cenv.g typ t.V
18631845
| _ -> false
18641846

18651847
override x.GetHashCode() = hash x
18661848

18671849
member x.Format(denv: FSharpDisplayContext) =
18681850
protect <| fun () ->
1869-
NicePrint.stringOfTy (denv.Contents cenv.g) typ
1851+
NicePrint.prettyStringOfTy (denv.Contents cenv.g) typ
18701852

18711853
override x.ToString() =
18721854
protect <| fun () ->
1873-
"type " + NicePrint.stringOfTy (DisplayEnv.Empty(cenv.g)) typ
1855+
"type " + NicePrint.prettyStringOfTy (DisplayEnv.Empty(cenv.g)) typ
1856+
1857+
static member Prettify(typ: FSharpType) =
1858+
let t = PrettyTypes.PrettifyTypes1 typ.cenv.g typ.V |> p23
1859+
typ.AdjustType t
1860+
1861+
static member Prettify(typs: IList<FSharpType>) =
1862+
let xs = typs |> List.ofSeq
1863+
match xs with
1864+
| [] -> []
1865+
| h :: _ ->
1866+
let cenv = h.cenv
1867+
let prettyTyps = PrettyTypes.PrettifyTypesN cenv.g [ for t in xs -> t.V ] |> p23
1868+
(xs, prettyTyps) ||> List.map2 (fun p pty -> p.AdjustType(pty))
1869+
|> makeReadOnlyCollection
1870+
1871+
static member Prettify(parameter: FSharpParameter) =
1872+
let prettyTyp = parameter.V |> PrettyTypes.PrettifyTypes1 parameter.cenv.g |> p23
1873+
parameter.AdjustType(prettyTyp)
1874+
1875+
static member Prettify(parameters: IList<FSharpParameter>) =
1876+
let parameters = parameters |> List.ofSeq
1877+
match parameters with
1878+
| [] -> []
1879+
| h :: _ ->
1880+
let cenv = h.cenv
1881+
let prettyTyps = parameters |> List.map (fun p -> p.V) |> PrettyTypes.PrettifyTypesN cenv.g |> p23
1882+
(parameters, prettyTyps) ||> List.map2 (fun p pty -> p.AdjustType(pty))
1883+
|> makeReadOnlyCollection
1884+
1885+
static member Prettify(parameters: IList<IList<FSharpParameter>>) =
1886+
let xs = parameters |> List.ofSeq |> List.map List.ofSeq
1887+
let hOpt = xs |> List.tryPick (function h :: _ -> Some h | _ -> None)
1888+
match hOpt with
1889+
| None -> xs
1890+
| Some h ->
1891+
let cenv = h.cenv
1892+
let prettyTyps = xs |> List.mapSquared (fun p -> p.V) |> PrettyTypes.PrettifyTypesNN cenv.g |> p23
1893+
(xs, prettyTyps) ||> List.map2 (List.map2 (fun p pty -> p.AdjustType(pty)))
1894+
|> List.map makeReadOnlyCollection |> makeReadOnlyCollection
1895+
1896+
static member Prettify(parameters: IList<IList<FSharpParameter>>, returnParameter: FSharpParameter) =
1897+
let xs = parameters |> List.ofSeq |> List.map List.ofSeq
1898+
let cenv = returnParameter.cenv
1899+
let prettyTyps, prettyRetTy = xs |> List.mapSquared (fun p -> p.V) |> (fun tys -> PrettyTypes.PrettifyTypesNN1 cenv.g (tys,returnParameter.Type) )|> p23
1900+
let ps = (xs, prettyTyps) ||> List.map2 (List.map2 (fun p pty -> p.AdjustType(pty))) |> List.map makeReadOnlyCollection |> makeReadOnlyCollection
1901+
ps, returnParameter.AdjustType(prettyRetTy)
18741902

18751903
and FSharpAttribute(cenv: cenv, attrib: AttribInfo) =
18761904

@@ -1956,7 +1984,10 @@ and FSharpParameter(cenv, typ:TType, topArgInfo:ArgReprInfo, mOpt, isParamArrayA
19561984
let idOpt = topArgInfo.Name
19571985
let m = match mOpt with Some m -> m | None -> range0
19581986
member __.Name = match idOpt with None -> None | Some v -> Some v.idText
1987+
member __.cenv : cenv = cenv
1988+
member __.AdjustType(t) = FSharpParameter(cenv, t, topArgInfo, mOpt, isParamArrayArg, isOutArg, isOptionalArg)
19591989
member __.Type = FSharpType(cenv, typ)
1990+
member __.V = typ
19601991
member __.DeclarationLocation = match idOpt with None -> m | Some v -> v.idRange
19611992
member __.Attributes =
19621993
attribs |> List.map (fun a -> FSharpAttribute(cenv, AttribInfo.FSAttribInfo(cenv.g, a))) |> makeReadOnlyCollection

‎src/fsharp/vs/Symbols.fsi‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -810,6 +810,7 @@ and [<Class>] FSharpParameter =
810810
/// Indicate this is an optional argument
811811
member IsOptionalArg: bool
812812

813+
813814
/// A subtype of FSharpSymbol that represents a single case within an active pattern
814815
and [<Class>] FSharpActivePatternCase =
815816
inherit FSharpSymbol
@@ -892,6 +893,30 @@ and [<Class>] FSharpType =
892893
/// if it is an instantiation of a generic type.
893894
member BaseType : FSharpType option
894895

896+
/// Adjust the type by removing any occurrences of type inference variables, replacing them
897+
/// systematically with lower-case type inference variables such as <c>'a</c>.
898+
static member Prettify : typ:FSharpType -> FSharpType
899+
900+
/// Adjust a group of types by removing any occurrences of type inference variables, replacing them
901+
/// systematically with lower-case type inference variables such as <c>'a</c>.
902+
static member Prettify : types: IList<FSharpType> -> IList<FSharpType>
903+
904+
/// Adjust the type in a single parameter by removing any occurrences of type inference variables, replacing them
905+
/// systematically with lower-case type inference variables such as <c>'a</c>.
906+
static member Prettify : parameter: FSharpParameter -> FSharpParameter
907+
908+
/// Adjust the types in a group of parameters by removing any occurrences of type inference variables, replacing them
909+
/// systematically with lower-case type inference variables such as <c>'a</c>.
910+
static member Prettify : parameters: IList<FSharpParameter> -> IList<FSharpParameter>
911+
912+
/// Adjust the types in a group of curried parameters by removing any occurrences of type inference variables, replacing them
913+
/// systematically with lower-case type inference variables such as <c>'a</c>.
914+
static member Prettify : parameters: IList<IList<FSharpParameter>> -> IList<IList<FSharpParameter>>
915+
916+
/// Adjust the types in a group of curried parameters and return type by removing any occurrences of type inference variables, replacing them
917+
/// systematically with lower-case type inference variables such as <c>'a</c>.
918+
static member Prettify : parameters: IList<IList<FSharpParameter>> * returnParameter: FSharpParameter -> IList<IList<FSharpParameter>>
919+
895920
[<System.Obsolete("Renamed to HasTypeDefinition")>]
896921
member IsNamedType : bool
897922

0 commit comments

Comments
 (0)