From 5f4a4da837a345c738063462b453375eeec13688 Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Tue, 5 Jul 2022 11:33:13 -1200 Subject: [PATCH 01/12] Update pars.fsy WIP --- src/Compiler/SyntaxTree/ParseHelpers.fs | 4 ++++ src/Compiler/SyntaxTree/ParseHelpers.fsi | 5 +++++ src/Compiler/SyntaxTree/SyntaxTree.fs | 4 +++- src/Compiler/SyntaxTree/SyntaxTree.fsi | 9 ++++----- src/Compiler/pars.fsy | 17 +++++++++++------ 5 files changed, 27 insertions(+), 12 deletions(-) diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index bcaebd20b92..0beb92e90c5 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -811,3 +811,7 @@ let mkSynMemberDefnGetSet [] | _ -> [] | _ -> [] + +let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = failwith "Todo" + +let mkDivideWithLeadingSlash (elementTypes: (bool * SynType) list) : SynType = failwith "TODO" diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index c240ab124e5..4d8e95b7cba 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -175,3 +175,8 @@ val mkSynMemberDefnGetSet: attrs: SynAttributeList list -> rangeStart: range -> SynMemberDefn list + +val mkTupleOrDivide: + isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool * SynType) list -> SynType + +val mkDivideWithLeadingSlash: elementTypes: (bool * SynType) list -> SynType diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index 9bcc3a8efe8..72c36cd4754 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -392,7 +392,9 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct: bool * elementTypes: (bool * SynType) list * range: range + | Tuple of isStruct: bool * elementTypes: SynType list * range: range + + | Division of elementTypes: (bool * SynType list) * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index 357823b658e..c9306ac1c29 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -457,11 +457,10 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of - // the bool is true if / rather than * follows the type - isStruct: bool * - elementTypes: (bool * SynType) list * - range: range + | Tuple of isStruct: bool * elementTypes: SynType list * range: range + + // TODO Add documentation + | Division of elementTypes: (bool * SynType list) * range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index ae048f25464..8da7c719176 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5020,7 +5020,7 @@ topType: topTupleType: | topAppType STAR topTupleTypeElements - { let ty, mdata = $1 in let tys, mdatas = List.unzip $3 in (SynType.Tuple(false, List.map (fun ty -> (false, ty)) (ty :: tys), lhs parseState)), (mdata :: mdatas) } + { let ty, mdata = $1 in let tys, mdatas = List.unzip $3 in (SynType.Tuple(false, List.map (fun ty -> (ty)) (ty :: tys), lhs parseState)), (mdata :: mdatas) } | topAppType { let ty, mdata = $1 in ty, [mdata] } @@ -5071,15 +5071,17 @@ typEOF: tupleType: | appType STAR tupleOrQuotTypeElements - { SynType.Tuple(false, (false, $1) :: $3, lhs parseState) } + { mkTupleOrDivide false $1 true $3 } | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); - SynType.Tuple(false, (true, SynType.StaticConstant (SynConst.Int32 1, lhs parseState)) :: $2, lhs parseState) } + //SynType.Division((SynType.StaticConstant (SynConst.Int32 1, lhs parseState)) :: $2, lhs parseState) + mkDivideWithLeadingSlash $2 } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); - SynType.Tuple(false, (true, $1) :: $3, lhs parseState) } + //SynType.Tuple(false, (true, $1) :: $3, lhs parseState) + mkTupleOrDivide false $1 false $3 } | appType %prec prec_tuptyp_prefix { $1 } @@ -5227,11 +5229,14 @@ atomType: SynType.Paren ($2, lhs parseState) } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements rparen - { SynType.Tuple(true, (false, $3) :: $5, lhs parseState) } + { + //SynType.Tuple(true, (false, $3) :: $5, lhs parseState) + mkTupleOrDivide true $3 true $5 } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) - SynType.Tuple(true, (false, $3) :: $5, lhs parseState) } + //SynType.Tuple(true, (false, $3) :: $5, lhs parseState) + mkTupleOrDivide true $3 true $5 } | STRUCT LPAREN appType STAR recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) From ce475b92d7eb3bf397c6404077bdce5486fbaf8d Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Wed, 6 Jul 2022 21:50:02 -1200 Subject: [PATCH 02/12] Update SynType.Tuple to catpture the division edgecase --- src/Compiler/SyntaxTree/ParseHelpers.fs | 4 ++-- src/Compiler/SyntaxTree/ParseHelpers.fsi | 4 ++-- src/Compiler/SyntaxTree/SyntaxTree.fs | 4 +--- src/Compiler/SyntaxTree/SyntaxTree.fsi | 5 +---- 4 files changed, 6 insertions(+), 11 deletions(-) diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index 0beb92e90c5..41e87891bb1 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -812,6 +812,6 @@ let mkSynMemberDefnGetSet | _ -> [] | _ -> [] -let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = failwith "Todo" +let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool option * SynType) list) : SynType = failwith "Todo" -let mkDivideWithLeadingSlash (elementTypes: (bool * SynType) list) : SynType = failwith "TODO" +let mkDivideWithLeadingSlash (elementTypes: (bool option * SynType) list) : SynType = failwith "TODO" diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index 4d8e95b7cba..61bccb79556 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -177,6 +177,6 @@ val mkSynMemberDefnGetSet: SynMemberDefn list val mkTupleOrDivide: - isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool * SynType) list -> SynType + isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool option * SynType) list -> SynType -val mkDivideWithLeadingSlash: elementTypes: (bool * SynType) list -> SynType +val mkDivideWithLeadingSlash: elementTypes: (bool option * SynType) list -> SynType diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index 72c36cd4754..2c9b21003e4 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -392,9 +392,7 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct: bool * elementTypes: SynType list * range: range - - | Division of elementTypes: (bool * SynType list) * range: range + | Tuple of isStruct: bool * elementTypes: (bool option * SynType) list * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index c9306ac1c29..c6dc5db502d 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -457,10 +457,7 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of isStruct: bool * elementTypes: SynType list * range: range - - // TODO Add documentation - | Division of elementTypes: (bool * SynType list) * range: range + | Tuple of isStruct: bool * elementTypes:(bool option * SynType) list * range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} From a53c4ec21a695a6fb699153547258e77df0c9862 Mon Sep 17 00:00:00 2001 From: Edgar Gonzalez Date: Fri, 15 Jul 2022 15:16:13 -1200 Subject: [PATCH 03/12] Update pars.fsy amd Helper to reflect the Star and Division --- src/Compiler/SyntaxTree/ParseHelpers.fs | 20 +++++++++++++++++--- src/Compiler/SyntaxTree/ParseHelpers.fsi | 6 ++++-- src/Compiler/SyntaxTree/SyntaxTree.fs | 2 +- src/Compiler/SyntaxTree/SyntaxTree.fsi | 3 ++- src/Compiler/pars.fsy | 2 +- 5 files changed, 25 insertions(+), 8 deletions(-) diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index ea65a856d66..aab21452d92 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -812,6 +812,20 @@ let mkSynMemberDefnGetSet | _ -> [] | _ -> [] -let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool option * SynType) list) : SynType = failwith "Todo" - -let mkDivideWithLeadingSlash (elementTypes: (bool option * SynType) list) : SynType = failwith "TODO" +// | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range + +// The last element of elementTypes does not have a star or slash +let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = + // x * y + let range = + (leadingType.Range, elementTypes) ||> List.fold (fun acc (_, t) -> unionRanges acc t.Range) + + let newElementTypes = + elementTypes + |> List.fold (fun (lastIsStar, currentList) (isStar , t) -> (isStar, (lastIsStar, t) :: currentList)) (isStar, []) + |> snd + |> List.rev + + SynType.Tuple(isStruct, false, leadingType, newElementTypes, range) + +let mkDivideWithLeadingSlash (_: (bool * SynType) list) : SynType = failwith "TODO" diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index 61bccb79556..d4d227824d9 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -177,6 +177,8 @@ val mkSynMemberDefnGetSet: SynMemberDefn list val mkTupleOrDivide: - isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool option * SynType) list -> SynType + isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool * SynType) list -> SynType -val mkDivideWithLeadingSlash: elementTypes: (bool option * SynType) list -> SynType +val mkDivideWithLeadingSlash: elementTypes: (bool * SynType) list -> SynType + +//| Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index 17a40cb295b..5d6977232f2 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -392,7 +392,7 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct: bool * elementTypes: (bool option * SynType) list * range: range + | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index bc2c230ffc4..4711ae7c98b 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -457,7 +457,8 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of isStruct: bool * elementTypes:(bool option * SynType) list * range: range + //| Tuple of isStruct: bool * elementTypes:(bool option * SynType) list * range: range + | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index 164d07a4fa2..276655aa746 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5029,7 +5029,7 @@ topType: topTupleType: | topAppType STAR topTupleTypeElements - { let ty, mdata = $1 in let tys, mdatas = List.unzip $3 in (SynType.Tuple(false, List.map (fun ty -> (ty)) (ty :: tys), lhs parseState)), (mdata :: mdatas) } + { let ty, mdata = $1 in let tys, mdatas = List.unzip $3 in (SynType.Tuple(false, false, ty, List.map (fun t -> false, t) tys, lhs parseState)), (mdata :: mdatas) } | topAppType { let ty, mdata = $1 in ty, [mdata] } From dfd8f29d23ec867721ae950fa815116528ccaf46 Mon Sep 17 00:00:00 2001 From: Edgar Date: Fri, 15 Jul 2022 22:36:38 +0100 Subject: [PATCH 04/12] WIP Update where SynTyp.Tuple is being use and fix build locally --- src/Compiler/Checking/CheckExpressions.fs | 2 +- src/Compiler/Service/ServiceParseTreeWalk.fs | 2 +- src/Compiler/Service/ServiceParsedInputOps.fs | 4 ++-- src/Compiler/SyntaxTree/ParseHelpers.fs | 2 -- src/Compiler/SyntaxTree/SyntaxTree.fsi | 1 - tests/service/ServiceUntypedParseTests.fs | 4 ++-- 6 files changed, 6 insertions(+), 9 deletions(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index 7e3baef258b..0155818bee8 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4538,7 +4538,7 @@ and TcTypeOrMeasure kindOpt cenv newOk checkConstraints occ env (tpenv: Unscoped | SynType.LongIdentApp (synLeftTy, synLongId, _, args, _commas, _, m) -> TcNestedAppType cenv newOk checkConstraints occ env tpenv synLeftTy synLongId args m - | SynType.Tuple(isStruct, args, m) -> + | SynType.Tuple(isStruct, _, _, args, m) -> TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct args m | SynType.AnonRecd(_, [],m) -> diff --git a/src/Compiler/Service/ServiceParseTreeWalk.fs b/src/Compiler/Service/ServiceParseTreeWalk.fs index e2eedc9ba47..3b3a59b15f0 100755 --- a/src/Compiler/Service/ServiceParseTreeWalk.fs +++ b/src/Compiler/Service/ServiceParseTreeWalk.fs @@ -819,7 +819,7 @@ module SyntaxTraversal = | SynType.Array (_, ty, _) -> traverseSynType path ty | SynType.StaticConstantNamed (ty1, ty2, _) | SynType.MeasureDivide (ty1, ty2, _) -> [ ty1; ty2 ] |> List.tryPick (traverseSynType path) - | SynType.Tuple (_, tys, _) -> tys |> List.map snd |> List.tryPick (traverseSynType path) + | SynType.Tuple(_, _, _, elements, _) -> elements |> List.map snd |> List.tryPick (traverseSynType path) | SynType.StaticConstantExpr (expr, _) -> traverseSynExpr [] expr | SynType.Anon _ -> None | _ -> None diff --git a/src/Compiler/Service/ServiceParsedInputOps.fs b/src/Compiler/Service/ServiceParsedInputOps.fs index a7ffb760e5a..f4eae365485 100644 --- a/src/Compiler/Service/ServiceParsedInputOps.fs +++ b/src/Compiler/Service/ServiceParsedInputOps.fs @@ -661,7 +661,7 @@ module ParsedInput = None | SynType.App (ty, _, types, _, _, _, _) -> walkType ty |> Option.orElseWith (fun () -> List.tryPick walkType types) | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.tryPick walkType types - | SynType.Tuple (_, ts, _) -> ts |> List.tryPick (fun (_, t) -> walkType t) + | SynType.Tuple(_, _, _, elements, _) -> elements |> List.tryPick (fun (_, t) -> walkType t) | SynType.Array (_, t, _) -> walkType t | SynType.Fun (argType = t1; returnType = t2) -> walkType t1 |> Option.orElseWith (fun () -> walkType t2) | SynType.WithGlobalConstraints (t, _, _) -> walkType t @@ -1669,7 +1669,7 @@ module ParsedInput = walkType ty List.iter walkType types | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.iter walkType types - | SynType.Tuple (_, ts, _) -> ts |> List.iter (fun (_, t) -> walkType t) + | SynType.Tuple(_, _, _, elements, _) -> elements |> List.iter (fun (_, t) -> walkType t) | SynType.WithGlobalConstraints (t, typeConstraints, _) -> walkType t List.iter walkTypeConstraint typeConstraints diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index aab21452d92..fc7879f945c 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -812,8 +812,6 @@ let mkSynMemberDefnGetSet | _ -> [] | _ -> [] -// | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range - // The last element of elementTypes does not have a star or slash let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = // x * y diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index 4711ae7c98b..eb802b87ea1 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -457,7 +457,6 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - //| Tuple of isStruct: bool * elementTypes:(bool option * SynType) list * range: range | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range /// F# syntax: {| id: type; ...; id: type |} diff --git a/tests/service/ServiceUntypedParseTests.fs b/tests/service/ServiceUntypedParseTests.fs index 9917ec23d27..8638c3e365c 100644 --- a/tests/service/ServiceUntypedParseTests.fs +++ b/tests/service/ServiceUntypedParseTests.fs @@ -156,8 +156,8 @@ let rec getParenTypes (synType: SynType): SynType list = yield! getParenTypes argType yield! getParenTypes returnType - | SynType.Tuple (_, types, _) -> - for _, synType in types do + | SynType.Tuple(_, _, _, elements, _) -> + for _, synType in elements do yield! getParenTypes synType | SynType.AnonRecd (_, fields, _) -> From 341050b9345017b7ab3d6669df99b2c8eda14a5d Mon Sep 17 00:00:00 2001 From: Edgar Date: Mon, 18 Jul 2022 17:17:30 +0100 Subject: [PATCH 05/12] Include firstType when used on Services and fix formatting --- src/Compiler/Service/ServiceParseTreeWalk.fs | 2 +- src/Compiler/Service/ServiceParsedInputOps.fs | 4 ++-- src/Compiler/SyntaxTree/ParseHelpers.fs | 9 +++++---- src/Compiler/SyntaxTree/SyntaxTree.fs | 2 +- src/Compiler/SyntaxTree/SyntaxTree.fsi | 7 ++++++- 5 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/Compiler/Service/ServiceParseTreeWalk.fs b/src/Compiler/Service/ServiceParseTreeWalk.fs index 3b3a59b15f0..1acdfb8c36a 100755 --- a/src/Compiler/Service/ServiceParseTreeWalk.fs +++ b/src/Compiler/Service/ServiceParseTreeWalk.fs @@ -819,7 +819,7 @@ module SyntaxTraversal = | SynType.Array (_, ty, _) -> traverseSynType path ty | SynType.StaticConstantNamed (ty1, ty2, _) | SynType.MeasureDivide (ty1, ty2, _) -> [ ty1; ty2 ] |> List.tryPick (traverseSynType path) - | SynType.Tuple(_, _, _, elements, _) -> elements |> List.map snd |> List.tryPick (traverseSynType path) + | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.tryPick (traverseSynType path) | SynType.StaticConstantExpr (expr, _) -> traverseSynExpr [] expr | SynType.Anon _ -> None | _ -> None diff --git a/src/Compiler/Service/ServiceParsedInputOps.fs b/src/Compiler/Service/ServiceParsedInputOps.fs index f4eae365485..199c69513b8 100644 --- a/src/Compiler/Service/ServiceParsedInputOps.fs +++ b/src/Compiler/Service/ServiceParsedInputOps.fs @@ -661,7 +661,7 @@ module ParsedInput = None | SynType.App (ty, _, types, _, _, _, _) -> walkType ty |> Option.orElseWith (fun () -> List.tryPick walkType types) | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.tryPick walkType types - | SynType.Tuple(_, _, _, elements, _) -> elements |> List.tryPick (fun (_, t) -> walkType t) + | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.tryPick (fun t -> walkType t) | SynType.Array (_, t, _) -> walkType t | SynType.Fun (argType = t1; returnType = t2) -> walkType t1 |> Option.orElseWith (fun () -> walkType t2) | SynType.WithGlobalConstraints (t, _, _) -> walkType t @@ -1669,7 +1669,7 @@ module ParsedInput = walkType ty List.iter walkType types | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.iter walkType types - | SynType.Tuple(_, _, _, elements, _) -> elements |> List.iter (fun (_, t) -> walkType t) + | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.iter (fun t -> walkType t) | SynType.WithGlobalConstraints (t, typeConstraints, _) -> walkType t List.iter walkTypeConstraint typeConstraints diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index fc7879f945c..4b431c09265 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -816,14 +816,15 @@ let mkSynMemberDefnGetSet let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = // x * y let range = - (leadingType.Range, elementTypes) ||> List.fold (fun acc (_, t) -> unionRanges acc t.Range) - + (leadingType.Range, elementTypes) + ||> List.fold (fun acc (_, t) -> unionRanges acc t.Range) + let newElementTypes = elementTypes - |> List.fold (fun (lastIsStar, currentList) (isStar , t) -> (isStar, (lastIsStar, t) :: currentList)) (isStar, []) + |> List.fold (fun (lastIsStar, currentList) (isStar, t) -> (isStar, (lastIsStar, t) :: currentList)) (isStar, []) |> snd |> List.rev - + SynType.Tuple(isStruct, false, leadingType, newElementTypes, range) let mkDivideWithLeadingSlash (_: (bool * SynType) list) : SynType = failwith "TODO" diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index 5d6977232f2..f8254e95a17 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -392,7 +392,7 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range + | Tuple of isStruct: bool * hasLeadingSlash: bool * firstType: SynType * elements: (bool * SynType) list * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index eb802b87ea1..b703027de72 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -457,7 +457,12 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range + | Tuple of + isStruct: bool * + hasLeadingSlash: bool * + firstType: SynType * + elements: (bool * SynType) list * + range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} From 87887efe484a2911a70e652cbc0460ef6b90b0df Mon Sep 17 00:00:00 2001 From: nojaf Date: Wed, 20 Jul 2022 10:57:35 +0200 Subject: [PATCH 06/12] Introduce TupleTypeSegment to SynType.Tuple. --- src/Compiler/Checking/CheckExpressions.fs | 40 +++++++-------- src/Compiler/Service/ServiceParseTreeWalk.fs | 2 +- src/Compiler/Service/ServiceParsedInputOps.fs | 4 +- src/Compiler/SyntaxTree/ParseHelpers.fs | 19 +++---- src/Compiler/SyntaxTree/ParseHelpers.fsi | 7 +-- src/Compiler/SyntaxTree/SyntaxTree.fs | 14 +++++- src/Compiler/SyntaxTree/SyntaxTree.fsi | 15 +++--- src/Compiler/SyntaxTree/SyntaxTreeOps.fs | 6 +++ src/Compiler/SyntaxTree/SyntaxTreeOps.fsi | 2 + src/Compiler/pars.fsy | 43 +++++++++++----- tests/service/ServiceUntypedParseTests.fs | 5 +- tests/service/SyntaxTreeTests/MeasureTests.fs | 50 +++++++++++++++++++ 12 files changed, 144 insertions(+), 63 deletions(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index 0155818bee8..de73c1e22a3 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4538,8 +4538,8 @@ and TcTypeOrMeasure kindOpt cenv newOk checkConstraints occ env (tpenv: Unscoped | SynType.LongIdentApp (synLeftTy, synLongId, _, args, _commas, _, m) -> TcNestedAppType cenv newOk checkConstraints occ env tpenv synLeftTy synLongId args m - | SynType.Tuple(isStruct, _, _, args, m) -> - TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct args m + | SynType.Tuple(isStruct, segments, m) -> + TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct segments m | SynType.AnonRecd(_, [],m) -> error(Error((FSComp.SR.tcAnonymousTypeInvalidInDeclaration()), m)) @@ -4649,24 +4649,24 @@ and TcNestedAppType cenv newOk checkConstraints occ env tpenv synLeftTy synLongI | _ -> error(Error(FSComp.SR.tcTypeHasNoNestedTypes(), m)) -and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct args m = - - let tupInfo = mkTupInfo isStruct - if isStruct then - let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m - TType_tuple(tupInfo, argsR), tpenv - else - let isMeasure = - match kindOpt with - | Some TyparKind.Measure -> true - | None -> List.exists (fun (isquot,_) -> isquot) args | _ -> false - - if isMeasure then - let ms,tpenv = TcMeasuresAsTuple cenv newOk checkConstraints occ env tpenv args m - TType_measure ms,tpenv - else - let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m - TType_tuple(tupInfo, argsR), tpenv +and TcTupleType _kindOpt _cenv _newOk _checkConstraints _occ _env _tpenv _isStruct _args _m = + failwith "todo" + // let tupInfo = mkTupInfo isStruct + // if isStruct then + // let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m + // TType_tuple(tupInfo, argsR), tpenv + // else + // let isMeasure = + // match kindOpt with + // | Some TyparKind.Measure -> true + // | None -> List.exists (fun (isquot,_) -> isquot) args | _ -> false + // + // if isMeasure then + // let ms,tpenv = TcMeasuresAsTuple cenv newOk checkConstraints occ env tpenv args m + // TType_measure ms,tpenv + // else + // let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m + // TType_tuple(tupInfo, argsR), tpenv and TcAnonRecdType cenv newOk checkConstraints occ env tpenv isStruct args m = let tupInfo = mkTupInfo isStruct diff --git a/src/Compiler/Service/ServiceParseTreeWalk.fs b/src/Compiler/Service/ServiceParseTreeWalk.fs index 1acdfb8c36a..6e4812eeb6d 100755 --- a/src/Compiler/Service/ServiceParseTreeWalk.fs +++ b/src/Compiler/Service/ServiceParseTreeWalk.fs @@ -819,7 +819,7 @@ module SyntaxTraversal = | SynType.Array (_, ty, _) -> traverseSynType path ty | SynType.StaticConstantNamed (ty1, ty2, _) | SynType.MeasureDivide (ty1, ty2, _) -> [ ty1; ty2 ] |> List.tryPick (traverseSynType path) - | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.tryPick (traverseSynType path) + | SynType.Tuple (path = segments) -> getTypeFromTuplePath segments |> List.tryPick (traverseSynType path) | SynType.StaticConstantExpr (expr, _) -> traverseSynExpr [] expr | SynType.Anon _ -> None | _ -> None diff --git a/src/Compiler/Service/ServiceParsedInputOps.fs b/src/Compiler/Service/ServiceParsedInputOps.fs index 199c69513b8..662a420ae0b 100644 --- a/src/Compiler/Service/ServiceParsedInputOps.fs +++ b/src/Compiler/Service/ServiceParsedInputOps.fs @@ -661,7 +661,7 @@ module ParsedInput = None | SynType.App (ty, _, types, _, _, _, _) -> walkType ty |> Option.orElseWith (fun () -> List.tryPick walkType types) | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.tryPick walkType types - | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.tryPick (fun t -> walkType t) + | SynType.Tuple (path = segments) -> getTypeFromTuplePath segments |> List.tryPick walkType | SynType.Array (_, t, _) -> walkType t | SynType.Fun (argType = t1; returnType = t2) -> walkType t1 |> Option.orElseWith (fun () -> walkType t2) | SynType.WithGlobalConstraints (t, _, _) -> walkType t @@ -1669,7 +1669,7 @@ module ParsedInput = walkType ty List.iter walkType types | SynType.LongIdentApp (_, _, _, types, _, _, _) -> List.iter walkType types - | SynType.Tuple (_, _, firstType, tys, _) -> firstType :: (List.map snd tys) |> List.iter (fun t -> walkType t) + | SynType.Tuple (path = segment) -> getTypeFromTuplePath segment |> List.iter walkType | SynType.WithGlobalConstraints (t, typeConstraints, _) -> walkType t List.iter walkTypeConstraint typeConstraints diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index 4b431c09265..de8e942164b 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -813,18 +813,13 @@ let mkSynMemberDefnGetSet | _ -> [] // The last element of elementTypes does not have a star or slash -let mkTupleOrDivide (isStruct: bool) (leadingType: SynType) (isStar: bool) (elementTypes: (bool * SynType) list) : SynType = - // x * y +let mkTupleOrDivide (isStruct: bool) (elementTypes: TupleTypeSegment list) : SynType = let range = - (leadingType.Range, elementTypes) - ||> List.fold (fun acc (_, t) -> unionRanges acc t.Range) + match elementTypes with + | [] -> Range.Zero + | head :: tail -> - let newElementTypes = - elementTypes - |> List.fold (fun (lastIsStar, currentList) (isStar, t) -> (isStar, (lastIsStar, t) :: currentList)) (isStar, []) - |> snd - |> List.rev + (head.Range, tail) + ||> List.fold (fun acc segment -> unionRanges acc segment.Range) - SynType.Tuple(isStruct, false, leadingType, newElementTypes, range) - -let mkDivideWithLeadingSlash (_: (bool * SynType) list) : SynType = failwith "TODO" + SynType.Tuple(isStruct, elementTypes, range) diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index d4d227824d9..ce4df6419ae 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -176,9 +176,4 @@ val mkSynMemberDefnGetSet: rangeStart: range -> SynMemberDefn list -val mkTupleOrDivide: - isStruct: bool -> leadingType: SynType -> isStar: bool -> elementTypes: (bool * SynType) list -> SynType - -val mkDivideWithLeadingSlash: elementTypes: (bool * SynType) list -> SynType - -//| Tuple of isStruct:bool * hasLeadingSlash:bool * firstType:SynType * elements: (bool * SynType) list * range: range +val mkTupleOrDivide: isStruct: bool -> elementTypes: TupleTypeSegment list -> SynType diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index f8254e95a17..bfdd6e9edfa 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -369,6 +369,18 @@ type SynTyparDecls = | PrefixList (range = range) -> range | SinglePrefix (range = range) -> range +[] +type TupleTypeSegment = + | Type of typeName: SynType + | Star of range: range + | Slash of range: range + + member this.Range = + match this with + | TupleTypeSegment.Type t -> t.Range + | TupleTypeSegment.Star (range = range) + | TupleTypeSegment.Slash (range = range) -> range + [] type SynType = @@ -392,7 +404,7 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct: bool * hasLeadingSlash: bool * firstType: SynType * elements: (bool * SynType) list * range: range + | Tuple of isStruct: bool * path: TupleTypeSegment list * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index b703027de72..694632893ca 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -427,6 +427,14 @@ type SynTyparDecls = member Constraints: SynTypeConstraint list member Range: range +[] +type TupleTypeSegment = + | Type of typeName: SynType + | Star of range: range + | Slash of range: range + + member Range: range + /// Represents a syntax tree for F# types [] type SynType = @@ -457,12 +465,7 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of - isStruct: bool * - hasLeadingSlash: bool * - firstType: SynType * - elements: (bool * SynType) list * - range: range + | Tuple of isStruct: bool * path: TupleTypeSegment list * range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} diff --git a/src/Compiler/SyntaxTree/SyntaxTreeOps.fs b/src/Compiler/SyntaxTree/SyntaxTreeOps.fs index 1834bb0fbf7..7fe33584537 100644 --- a/src/Compiler/SyntaxTree/SyntaxTreeOps.fs +++ b/src/Compiler/SyntaxTree/SyntaxTreeOps.fs @@ -1017,3 +1017,9 @@ let rec desugarGetSetMembers (memberDefns: SynMemberDefns) = let members = Option.map desugarGetSetMembers members [ SynMemberDefn.Interface(interfaceType, withKeyword, members, m) ] | md -> [ md ]) + +let getTypeFromTuplePath (path: TupleTypeSegment list) : SynType list = + path + |> List.choose (function + | TupleTypeSegment.Type t -> Some t + | _ -> None) diff --git a/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi b/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi index 0c7010b40fa..4d3879792ba 100644 --- a/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi @@ -344,3 +344,5 @@ val mkDynamicArgExpr: expr: SynExpr -> SynExpr val normalizeTupleExpr: exprs: SynExpr list -> commas: range list -> SynExpr list * range List val desugarGetSetMembers: memberDefns: SynMemberDefns -> SynMemberDefns + +val getTypeFromTuplePath: path: TupleTypeSegment list -> SynType list diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index 276655aa746..e78ce3fd305 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5029,17 +5029,23 @@ topType: topTupleType: | topAppType STAR topTupleTypeElements - { let ty, mdata = $1 in let tys, mdatas = List.unzip $3 in (SynType.Tuple(false, false, ty, List.map (fun t -> false, t) tys, lhs parseState)), (mdata :: mdatas) } + { let t, argInfo = $1 + let path = TupleTypeSegment.Type t :: (List.map fst $3) + let mdata = argInfo :: (List.choose snd $3) + mkTupleOrDivide false path, mdata } | topAppType { let ty, mdata = $1 in ty, [mdata] } topTupleTypeElements: | topAppType STAR topTupleTypeElements - { $1 :: $3 } + { let t, argInfo = $1 + let mStar = rhs parseState 2 + (TupleTypeSegment.Type t, Some argInfo) :: (TupleTypeSegment.Star mStar, None) :: $3 } | topAppType %prec prec_toptuptyptail_prefix - { [$1] } + { let t, argInfo = $1 + [ TupleTypeSegment.Type t, Some argInfo ] } topAppType: | attributes appType COLON appType @@ -5080,31 +5086,39 @@ typEOF: tupleType: | appType STAR tupleOrQuotTypeElements - { mkTupleOrDivide false $1 true $3 } + { let mStar = rhs parseState 2 + let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Star mStar :: $3 + mkTupleOrDivide false path } | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); //SynType.Division((SynType.StaticConstant (SynConst.Int32 1, lhs parseState)) :: $2, lhs parseState) - mkDivideWithLeadingSlash $2 } + let mSlash = rhs parseState 1 + let path = TupleTypeSegment.Slash mSlash :: $2 + mkTupleOrDivide false path } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); //SynType.Tuple(false, (true, $1) :: $3, lhs parseState) - mkTupleOrDivide false $1 false $3 } + let mSlash = rhs parseState 2 + let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 + mkTupleOrDivide false path } | appType %prec prec_tuptyp_prefix { $1 } tupleOrQuotTypeElements: | appType STAR tupleOrQuotTypeElements - { (false, $1) :: $3 } + { let mStar = rhs parseState 2 + TupleTypeSegment.Type $1 :: TupleTypeSegment.Star mStar :: $3 } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); - (true, $1) :: $3 } + let mSlash = rhs parseState 2 + TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 } | appType %prec prec_tuptyptail_prefix - { [(false, $1)] } + { [ TupleTypeSegment.Type $1 ] } appTypeCon: | path %prec prec_atomtyp_path @@ -5238,14 +5252,17 @@ atomType: SynType.Paren ($2, lhs parseState) } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements rparen - { + { let mStar = rhs parseState 4 + let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 //SynType.Tuple(true, (false, $3) :: $5, lhs parseState) - mkTupleOrDivide true $3 true $5 } + mkTupleOrDivide true path } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) - //SynType.Tuple(true, (false, $3) :: $5, lhs parseState) - mkTupleOrDivide true $3 true $5 } + //SynType.Tuple(true, (false, $3) :: $5, lhs parseState + let mStar = rhs parseState 4 + let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 + mkTupleOrDivide true path } | STRUCT LPAREN appType STAR recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) diff --git a/tests/service/ServiceUntypedParseTests.fs b/tests/service/ServiceUntypedParseTests.fs index 8638c3e365c..19716749a39 100644 --- a/tests/service/ServiceUntypedParseTests.fs +++ b/tests/service/ServiceUntypedParseTests.fs @@ -12,6 +12,7 @@ open FsUnit open FSharp.Compiler.EditorServices open FSharp.Compiler.Service.Tests.Common open FSharp.Compiler.Syntax +open FSharp.Compiler.SyntaxTreeOps open FSharp.Compiler.Text open FSharp.Compiler.Text.Position open NUnit.Framework @@ -156,8 +157,8 @@ let rec getParenTypes (synType: SynType): SynType list = yield! getParenTypes argType yield! getParenTypes returnType - | SynType.Tuple(_, _, _, elements, _) -> - for _, synType in elements do + | SynType.Tuple(path = segment) -> + for synType in getTypeFromTuplePath segment do yield! getParenTypes synType | SynType.AnonRecd (_, fields, _) -> diff --git a/tests/service/SyntaxTreeTests/MeasureTests.fs b/tests/service/SyntaxTreeTests/MeasureTests.fs index 0ccbf5a6d5d..e23e2782e41 100644 --- a/tests/service/SyntaxTreeTests/MeasureTests.fs +++ b/tests/service/SyntaxTreeTests/MeasureTests.fs @@ -46,4 +46,54 @@ let ``SynMeasure.Paren has correct range`` () = Assert.AreEqual("staff", staffIdent.idText) Assert.AreEqual("weeks", weeksIdent.idText) assertRange (2, 9) (2, 22) mParen + | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" + +let private (|TypeName|_|) t = + match t with + | SynType.LongIdent(SynLongIdent([ident], _, _)) -> Some ident.idText + | _ -> None + +[] +let ``SynType.Tuple in measure type with no slashes`` () = + let parseResults = + getParseResults + """ +[] type X = Y * Z +""" + + match parseResults with + | ParsedInput.ImplFile (ParsedImplFileInput (modules = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [ + SynModuleDecl.Types(typeDefns = [ + SynTypeDefn(typeRepr = + SynTypeDefnRepr.Simple(simpleRepr = + SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = + SynType.Tuple(false, [ TupleTypeSegment.Type (TypeName "Y") + TupleTypeSegment.Star mStar + TupleTypeSegment.Type (TypeName "Z") ], mTuple)))) + ]) + ]) ])) -> + assertRange (2, 23) (2, 24) mStar + assertRange (2, 21) (2, 26) mTuple + | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" + +[] +let ``SynType.Tuple in measure type with leading slash`` () = + let parseResults = + getParseResults + """ +[] type X = / second +""" + + match parseResults with + | ParsedInput.ImplFile (ParsedImplFileInput (modules = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [ + SynModuleDecl.Types(typeDefns = [ + SynTypeDefn(typeRepr = + SynTypeDefnRepr.Simple(simpleRepr = + SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = + SynType.Tuple(false, [ TupleTypeSegment.Slash mSlash + TupleTypeSegment.Type (TypeName "second") ], mTuple)))) + ]) + ]) ])) -> + assertRange (2, 21) (2, 22) mSlash + assertRange (2, 21) (2, 29) mTuple | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" \ No newline at end of file From f0b2075d7040e9cbb884665e11004157bbc3e94d Mon Sep 17 00:00:00 2001 From: Edgar Date: Wed, 20 Jul 2022 11:24:17 +0100 Subject: [PATCH 07/12] Update CheckDeclaration --- src/Compiler/Checking/CheckExpressions.fs | 85 +++++++++++++++-------- 1 file changed, 57 insertions(+), 28 deletions(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index de73c1e22a3..a8b0c836919 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4649,28 +4649,27 @@ and TcNestedAppType cenv newOk checkConstraints occ env tpenv synLeftTy synLongI | _ -> error(Error(FSComp.SR.tcTypeHasNoNestedTypes(), m)) -and TcTupleType _kindOpt _cenv _newOk _checkConstraints _occ _env _tpenv _isStruct _args _m = - failwith "todo" - // let tupInfo = mkTupInfo isStruct - // if isStruct then - // let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m - // TType_tuple(tupInfo, argsR), tpenv - // else - // let isMeasure = - // match kindOpt with - // | Some TyparKind.Measure -> true - // | None -> List.exists (fun (isquot,_) -> isquot) args | _ -> false - // - // if isMeasure then - // let ms,tpenv = TcMeasuresAsTuple cenv newOk checkConstraints occ env tpenv args m - // TType_measure ms,tpenv - // else - // let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m - // TType_tuple(tupInfo, argsR), tpenv +and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args: TupleTypeSegment list) m = + let tupInfo = mkTupInfo isStruct + if isStruct then + let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m + TType_tuple(tupInfo, argsR), tpenv + else + let isMeasure = + match kindOpt with + | Some TyparKind.Measure -> true + | None | Some _ -> args |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + + if isMeasure then + let ms,tpenv = TcMeasuresAsTuple cenv newOk checkConstraints occ env tpenv args m + TType_measure ms,tpenv + else + let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m + TType_tuple(tupInfo, argsR), tpenv and TcAnonRecdType cenv newOk checkConstraints occ env tpenv isStruct args m = let tupInfo = mkTupInfo isStruct - let tup = args |> List.map snd |> List.map (fun x -> (false, x)) + let tup = args |> List.map (fun (_, t) -> TupleTypeSegment.Type t) let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv tup m let unsortedFieldIds = args |> List.map fst |> List.toArray let anonInfo = AnonRecdTypeInfo.Create(cenv.thisCcu, tupInfo, unsortedFieldIds) @@ -4808,25 +4807,55 @@ and TcAnonTypeOrMeasure kindOpt _cenv rigid dyn newOk m = and TcTypes cenv newOk checkConstraints occ env tpenv args = List.mapFold (TcTypeAndRecover cenv newOk checkConstraints occ env) tpenv args -and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m = +and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: TupleTypeSegment list) m = + // check if any is a slash, if so, errorR(Error(FSComp.SR.tcUnexpectedSlashInType(), m)) + let hasASlash = + args + |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + + if hasASlash then errorR(Error(FSComp.SR.tcUnexpectedSlashInType(), m)) + + let args : SynType list = getTypeFromTuplePath args match args with | [] -> error(InternalError("empty tuple type", m)) - | [(_, ty)] -> let ty, tpenv = TcTypeAndRecover cenv newOk checkConstraints occ env tpenv ty in [ty], tpenv - | (isquot, ty) :: args -> + | [ty] -> let ty, tpenv = TcTypeAndRecover cenv newOk checkConstraints occ env tpenv ty in [ty], tpenv + | ty :: args -> let ty, tpenv = TcTypeAndRecover cenv newOk checkConstraints occ env tpenv ty + let args = List.map TupleTypeSegment.Type args let tys, tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m - if isquot then errorR(Error(FSComp.SR.tcUnexpectedSlashInType(), m)) ty :: tys, tpenv // Type-check a list of measures separated by juxtaposition, * or / -and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparEnv) args m = - let rec gather args tpenv isquot acc = +and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparEnv) (args: TupleTypeSegment list) m = + // go over the path, and pattern + // x * y + // x / y + // / second + // * / * + // [ Slash ; Type] + + let rec gather (args: TupleTypeSegment list) tpenv acc = match args with | [] -> acc, tpenv - | (nextisquot, ty) :: args -> + | TupleTypeSegment.Type ty :: args -> + let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m + gather args tpenv ms1 + | TupleTypeSegment.Star _ :: TupleTypeSegment.Type ty :: args -> let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m - gather args tpenv nextisquot (if isquot then Measure.Prod(acc, Measure.Inv ms1) else Measure.Prod(acc, ms1)) - gather args tpenv false Measure.One + gather args tpenv (Measure.Prod(acc, ms1)) + | TupleTypeSegment.Slash _ :: TupleTypeSegment.Type ty :: args -> + let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m + gather args tpenv (Measure.Prod(acc, Measure.Inv ms1)) + | _ -> failwith "Not expected scenario" + + // let rec gather args tpenv isquot acc = + // match args with + // | [] -> acc, tpenv + // | (nextisquot, ty) :: args -> + // let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m + // gather args tpenv nextisquot (if isquot then Measure.Prod(acc, Measure.Inv ms1) else Measure.Prod(acc, ms1)) + + gather args tpenv Measure.One and TcTypesOrMeasures optKinds cenv newOk checkConstraints occ env tpenv args m = match optKinds with From c05f5e20a35af662b6ec49635dabad11b299df81 Mon Sep 17 00:00:00 2001 From: nojaf Date: Wed, 20 Jul 2022 13:17:35 +0200 Subject: [PATCH 08/12] Update SurfaceArea --- ...erService.SurfaceArea.netstandard.expected | 38 ++++++++++++++++--- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected index 1f16bf7c33c..7ca04a5d7eb 100644 --- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected +++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected @@ -2081,12 +2081,14 @@ FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String get_FileName( FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] DependencyFiles FSharp.Compiler.CodeAnalysis.FSharpParseFileResults: System.String[] get_DependencyFiles() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions +FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean ApplyLineDirectives FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean CompilingFSharpCore FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(FSharp.Compiler.CodeAnalysis.FSharpParsingOptions) FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(System.Object) FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean IsExe FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean IsInteractive +FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_ApplyLineDirectives() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_CompilingFSharpCore() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_IsExe() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_IsInteractive() @@ -2108,8 +2110,6 @@ FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String ToString() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String get_LangVersionText() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] SourceFiles FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: System.String[] get_SourceFiles() -FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean ApplyLineDirectives -FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Boolean get_ApplyLineDirectives() FSharp.Compiler.CodeAnalysis.FSharpParsingOptions: Void .ctor(System.String[], Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.String], FSharp.Compiler.Diagnostics.FSharpDiagnosticOptions, System.String, Boolean, Microsoft.FSharp.Core.FSharpOption`1[System.Boolean], Boolean, Boolean) FSharp.Compiler.CodeAnalysis.FSharpProjectContext FSharp.Compiler.CodeAnalysis.FSharpProjectContext: FSharp.Compiler.CodeAnalysis.FSharpProjectOptions ProjectOptions @@ -8477,8 +8477,8 @@ FSharp.Compiler.Syntax.SynType+Tuple: Boolean get_isStruct() FSharp.Compiler.Syntax.SynType+Tuple: Boolean isStruct FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range get_range() FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range range -FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Boolean,FSharp.Compiler.Syntax.SynType]] elementTypes -FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Boolean,FSharp.Compiler.Syntax.SynType]] get_elementTypes() +FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment] get_path() +FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment] path FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar get_typar() FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar typar FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Text.Range get_range() @@ -8537,7 +8537,7 @@ FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewParen(FSharp.C FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstant(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantExpr(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantNamed(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range) -FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.Boolean,FSharp.Compiler.Syntax.SynType]], FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewVar(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewWithGlobalConstraints(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Anon @@ -9145,6 +9145,34 @@ FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOptio FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitTypeAbbrev(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitUnionDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Void .ctor() +FSharp.Compiler.Syntax.TupleTypeSegment +FSharp.Compiler.Syntax.TupleTypeSegment+Slash: FSharp.Compiler.Text.Range get_range() +FSharp.Compiler.Syntax.TupleTypeSegment+Slash: FSharp.Compiler.Text.Range range +FSharp.Compiler.Syntax.TupleTypeSegment+Star: FSharp.Compiler.Text.Range get_range() +FSharp.Compiler.Syntax.TupleTypeSegment+Star: FSharp.Compiler.Text.Range range +FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Slash +FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Star +FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Type +FSharp.Compiler.Syntax.TupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType get_typeName() +FSharp.Compiler.Syntax.TupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType typeName +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsSlash +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsStar +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsType +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsSlash() +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsStar() +FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsType() +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewSlash(FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewStar(FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewType(FSharp.Compiler.Syntax.SynType) +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Slash +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Star +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Tags +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Type +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Text.Range Range +FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Text.Range get_Range() +FSharp.Compiler.Syntax.TupleTypeSegment: Int32 Tag +FSharp.Compiler.Syntax.TupleTypeSegment: Int32 get_Tag() +FSharp.Compiler.Syntax.TupleTypeSegment: System.String ToString() FSharp.Compiler.Syntax.TyparStaticReq FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 HeadType FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 None From 080f98d938873a87319889b9a83884fb3f8dad6f Mon Sep 17 00:00:00 2001 From: nojaf Date: Mon, 25 Jul 2022 09:55:46 +0200 Subject: [PATCH 09/12] Non measure kinds are not measures. --- src/Compiler/Checking/CheckExpressions.fs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index a8b0c836919..57bbf259dce 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4658,7 +4658,8 @@ and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args let isMeasure = match kindOpt with | Some TyparKind.Measure -> true - | None | Some _ -> args |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + | None -> args |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + | Some _ -> false if isMeasure then let ms,tpenv = TcMeasuresAsTuple cenv newOk checkConstraints occ env tpenv args m From 90ece5ea23305ff8c7ba1c419b775f871c9265ff Mon Sep 17 00:00:00 2001 From: Edgar Date: Mon, 25 Jul 2022 16:59:59 +0100 Subject: [PATCH 10/12] Code clean up --- src/Compiler/Checking/CheckExpressions.fs | 18 +----------------- src/Compiler/pars.fsy | 4 ---- 2 files changed, 1 insertion(+), 21 deletions(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index 57bbf259dce..e6a7d588bc1 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4809,7 +4809,6 @@ and TcTypes cenv newOk checkConstraints occ env tpenv args = List.mapFold (TcTypeAndRecover cenv newOk checkConstraints occ env) tpenv args and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: TupleTypeSegment list) m = - // check if any is a slash, if so, errorR(Error(FSComp.SR.tcUnexpectedSlashInType(), m)) let hasASlash = args |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) @@ -4828,13 +4827,6 @@ and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: TupleTypeSeg // Type-check a list of measures separated by juxtaposition, * or / and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparEnv) (args: TupleTypeSegment list) m = - // go over the path, and pattern - // x * y - // x / y - // / second - // * / * - // [ Slash ; Type] - let rec gather (args: TupleTypeSegment list) tpenv acc = match args with | [] -> acc, tpenv @@ -4847,15 +4839,7 @@ and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparE | TupleTypeSegment.Slash _ :: TupleTypeSegment.Type ty :: args -> let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m gather args tpenv (Measure.Prod(acc, Measure.Inv ms1)) - | _ -> failwith "Not expected scenario" - - // let rec gather args tpenv isquot acc = - // match args with - // | [] -> acc, tpenv - // | (nextisquot, ty) :: args -> - // let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m - // gather args tpenv nextisquot (if isquot then Measure.Prod(acc, Measure.Inv ms1) else Measure.Prod(acc, ms1)) - + | _ -> failwith "inpossible" gather args tpenv Measure.One and TcTypesOrMeasures optKinds cenv newOk checkConstraints occ env tpenv args m = diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index e78ce3fd305..85a74b566c4 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5092,14 +5092,12 @@ tupleType: | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); - //SynType.Division((SynType.StaticConstant (SynConst.Int32 1, lhs parseState)) :: $2, lhs parseState) let mSlash = rhs parseState 1 let path = TupleTypeSegment.Slash mSlash :: $2 mkTupleOrDivide false path } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); - //SynType.Tuple(false, (true, $1) :: $3, lhs parseState) let mSlash = rhs parseState 2 let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 mkTupleOrDivide false path } @@ -5254,12 +5252,10 @@ atomType: | STRUCT LPAREN appType STAR tupleOrQuotTypeElements rparen { let mStar = rhs parseState 4 let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 - //SynType.Tuple(true, (false, $3) :: $5, lhs parseState) mkTupleOrDivide true path } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) - //SynType.Tuple(true, (false, $3) :: $5, lhs parseState let mStar = rhs parseState 4 let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 mkTupleOrDivide true path } From 4f35c897553a15331af160a5a09847b7502a6803 Mon Sep 17 00:00:00 2001 From: Edgar Date: Mon, 25 Jul 2022 19:41:11 +0100 Subject: [PATCH 11/12] Rename Parser helper function, update pars.fsy , Add more testing --- src/Compiler/SyntaxTree/ParseHelpers.fs | 2 +- src/Compiler/SyntaxTree/ParseHelpers.fsi | 2 +- src/Compiler/pars.fsy | 12 ++++---- tests/service/SyntaxTreeTests/MeasureTests.fs | 28 ++++++++++++++++++- 4 files changed, 35 insertions(+), 9 deletions(-) diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index de8e942164b..6e2d4fca8df 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -813,7 +813,7 @@ let mkSynMemberDefnGetSet | _ -> [] // The last element of elementTypes does not have a star or slash -let mkTupleOrDivide (isStruct: bool) (elementTypes: TupleTypeSegment list) : SynType = +let mkSynTypeTuple (isStruct: bool) (elementTypes: TupleTypeSegment list) : SynType = let range = match elementTypes with | [] -> Range.Zero diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index ce4df6419ae..19697f067bf 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -176,4 +176,4 @@ val mkSynMemberDefnGetSet: rangeStart: range -> SynMemberDefn list -val mkTupleOrDivide: isStruct: bool -> elementTypes: TupleTypeSegment list -> SynType +val mkSynTypeTuple: isStruct: bool -> elementTypes: TupleTypeSegment list -> SynType diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index 85a74b566c4..321d1a4f670 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5032,7 +5032,7 @@ topTupleType: { let t, argInfo = $1 let path = TupleTypeSegment.Type t :: (List.map fst $3) let mdata = argInfo :: (List.choose snd $3) - mkTupleOrDivide false path, mdata } + mkSynTypeTuple false path, mdata } | topAppType { let ty, mdata = $1 in ty, [mdata] } @@ -5088,19 +5088,19 @@ tupleType: | appType STAR tupleOrQuotTypeElements { let mStar = rhs parseState 2 let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Star mStar :: $3 - mkTupleOrDivide false path } + mkSynTypeTuple false path } | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); let mSlash = rhs parseState 1 let path = TupleTypeSegment.Slash mSlash :: $2 - mkTupleOrDivide false path } + mkSynTypeTuple false path } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); let mSlash = rhs parseState 2 let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 - mkTupleOrDivide false path } + mkSynTypeTuple false path } | appType %prec prec_tuptyp_prefix { $1 } @@ -5252,13 +5252,13 @@ atomType: | STRUCT LPAREN appType STAR tupleOrQuotTypeElements rparen { let mStar = rhs parseState 4 let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 - mkTupleOrDivide true path } + mkSynTypeTuple true path } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) let mStar = rhs parseState 4 let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 - mkTupleOrDivide true path } + mkSynTypeTuple true path } | STRUCT LPAREN appType STAR recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) diff --git a/tests/service/SyntaxTreeTests/MeasureTests.fs b/tests/service/SyntaxTreeTests/MeasureTests.fs index e23e2782e41..73c7825cbd7 100644 --- a/tests/service/SyntaxTreeTests/MeasureTests.fs +++ b/tests/service/SyntaxTreeTests/MeasureTests.fs @@ -96,4 +96,30 @@ let ``SynType.Tuple in measure type with leading slash`` () = ]) ])) -> assertRange (2, 21) (2, 22) mSlash assertRange (2, 21) (2, 29) mTuple - | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" \ No newline at end of file + | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" + +[] +let ``SynType.Tuple in measure type with start and slash`` () = + let parseResults = + getParseResults + """ +[] type R = X * Y / Z +""" + + match parseResults with + | ParsedInput.ImplFile (ParsedImplFileInput (modules = [ SynModuleOrNamespace.SynModuleOrNamespace(decls = [ + SynModuleDecl.Types(typeDefns = [ + SynTypeDefn(typeRepr = + SynTypeDefnRepr.Simple(simpleRepr = + SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = + SynType.Tuple(false, [ TupleTypeSegment.Type (TypeName "X") + TupleTypeSegment.Star msStar + TupleTypeSegment.Type (TypeName "Y") + TupleTypeSegment.Slash msSlash + TupleTypeSegment.Type (TypeName "Z") ], mTuple)))) + ]) + ]) ])) -> + assertRange (2, 23) (2, 24) msStar + assertRange (2, 21) (2, 30) mTuple + assertRange (2, 27) (2, 28) msSlash + | _ -> Assert.Fail $"Could not get valid AST, got {parseResults}" From d15394589ff30e4e55c92ad61fe592b38d1aa85f Mon Sep 17 00:00:00 2001 From: nojaf Date: Thu, 28 Jul 2022 16:19:37 +0200 Subject: [PATCH 12/12] Rename TupleTypeSegment to SynTupleTypeSegment. --- src/Compiler/Checking/CheckExpressions.fs | 22 +++---- src/Compiler/SyntaxTree/ParseHelpers.fs | 2 +- src/Compiler/SyntaxTree/ParseHelpers.fsi | 2 +- src/Compiler/SyntaxTree/SyntaxTree.fs | 10 +-- src/Compiler/SyntaxTree/SyntaxTree.fsi | 4 +- src/Compiler/SyntaxTree/SyntaxTreeOps.fs | 4 +- src/Compiler/SyntaxTree/SyntaxTreeOps.fsi | 2 +- src/Compiler/pars.fsy | 22 +++---- ...erService.SurfaceArea.netstandard.expected | 62 +++++++++---------- tests/service/SyntaxTreeTests/MeasureTests.fs | 20 +++--- 10 files changed, 75 insertions(+), 75 deletions(-) diff --git a/src/Compiler/Checking/CheckExpressions.fs b/src/Compiler/Checking/CheckExpressions.fs index e6a7d588bc1..fd970a58cac 100644 --- a/src/Compiler/Checking/CheckExpressions.fs +++ b/src/Compiler/Checking/CheckExpressions.fs @@ -4649,7 +4649,7 @@ and TcNestedAppType cenv newOk checkConstraints occ env tpenv synLeftTy synLongI | _ -> error(Error(FSComp.SR.tcTypeHasNoNestedTypes(), m)) -and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args: TupleTypeSegment list) m = +and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args: SynTupleTypeSegment list) m = let tupInfo = mkTupInfo isStruct if isStruct then let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m @@ -4658,7 +4658,7 @@ and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args let isMeasure = match kindOpt with | Some TyparKind.Measure -> true - | None -> args |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + | None -> args |> List.exists(function | SynTupleTypeSegment.Slash _ -> true | _ -> false) | Some _ -> false if isMeasure then @@ -4670,7 +4670,7 @@ and TcTupleType kindOpt cenv newOk checkConstraints occ env tpenv isStruct (args and TcAnonRecdType cenv newOk checkConstraints occ env tpenv isStruct args m = let tupInfo = mkTupInfo isStruct - let tup = args |> List.map (fun (_, t) -> TupleTypeSegment.Type t) + let tup = args |> List.map (fun (_, t) -> SynTupleTypeSegment.Type t) let argsR,tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv tup m let unsortedFieldIds = args |> List.map fst |> List.toArray let anonInfo = AnonRecdTypeInfo.Create(cenv.thisCcu, tupInfo, unsortedFieldIds) @@ -4808,10 +4808,10 @@ and TcAnonTypeOrMeasure kindOpt _cenv rigid dyn newOk m = and TcTypes cenv newOk checkConstraints occ env tpenv args = List.mapFold (TcTypeAndRecover cenv newOk checkConstraints occ env) tpenv args -and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: TupleTypeSegment list) m = +and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: SynTupleTypeSegment list) m = let hasASlash = args - |> List.exists(function | TupleTypeSegment.Slash _ -> true | _ -> false) + |> List.exists(function | SynTupleTypeSegment.Slash _ -> true | _ -> false) if hasASlash then errorR(Error(FSComp.SR.tcUnexpectedSlashInType(), m)) @@ -4821,22 +4821,22 @@ and TcTypesAsTuple cenv newOk checkConstraints occ env tpenv (args: TupleTypeSeg | [ty] -> let ty, tpenv = TcTypeAndRecover cenv newOk checkConstraints occ env tpenv ty in [ty], tpenv | ty :: args -> let ty, tpenv = TcTypeAndRecover cenv newOk checkConstraints occ env tpenv ty - let args = List.map TupleTypeSegment.Type args + let args = List.map SynTupleTypeSegment.Type args let tys, tpenv = TcTypesAsTuple cenv newOk checkConstraints occ env tpenv args m ty :: tys, tpenv // Type-check a list of measures separated by juxtaposition, * or / -and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparEnv) (args: TupleTypeSegment list) m = - let rec gather (args: TupleTypeSegment list) tpenv acc = +and TcMeasuresAsTuple cenv newOk checkConstraints occ env (tpenv: UnscopedTyparEnv) (args: SynTupleTypeSegment list) m = + let rec gather (args: SynTupleTypeSegment list) tpenv acc = match args with | [] -> acc, tpenv - | TupleTypeSegment.Type ty :: args -> + | SynTupleTypeSegment.Type ty :: args -> let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m gather args tpenv ms1 - | TupleTypeSegment.Star _ :: TupleTypeSegment.Type ty :: args -> + | SynTupleTypeSegment.Star _ :: SynTupleTypeSegment.Type ty :: args -> let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m gather args tpenv (Measure.Prod(acc, ms1)) - | TupleTypeSegment.Slash _ :: TupleTypeSegment.Type ty :: args -> + | SynTupleTypeSegment.Slash _ :: SynTupleTypeSegment.Type ty :: args -> let ms1, tpenv = TcMeasure cenv newOk checkConstraints occ env tpenv ty m gather args tpenv (Measure.Prod(acc, Measure.Inv ms1)) | _ -> failwith "inpossible" diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fs b/src/Compiler/SyntaxTree/ParseHelpers.fs index 6e2d4fca8df..4cb172651ad 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fs +++ b/src/Compiler/SyntaxTree/ParseHelpers.fs @@ -813,7 +813,7 @@ let mkSynMemberDefnGetSet | _ -> [] // The last element of elementTypes does not have a star or slash -let mkSynTypeTuple (isStruct: bool) (elementTypes: TupleTypeSegment list) : SynType = +let mkSynTypeTuple (isStruct: bool) (elementTypes: SynTupleTypeSegment list) : SynType = let range = match elementTypes with | [] -> Range.Zero diff --git a/src/Compiler/SyntaxTree/ParseHelpers.fsi b/src/Compiler/SyntaxTree/ParseHelpers.fsi index 19697f067bf..e84c3759fbe 100644 --- a/src/Compiler/SyntaxTree/ParseHelpers.fsi +++ b/src/Compiler/SyntaxTree/ParseHelpers.fsi @@ -176,4 +176,4 @@ val mkSynMemberDefnGetSet: rangeStart: range -> SynMemberDefn list -val mkSynTypeTuple: isStruct: bool -> elementTypes: TupleTypeSegment list -> SynType +val mkSynTypeTuple: isStruct: bool -> elementTypes: SynTupleTypeSegment list -> SynType diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fs b/src/Compiler/SyntaxTree/SyntaxTree.fs index bfdd6e9edfa..cf4e3e1b4da 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fs +++ b/src/Compiler/SyntaxTree/SyntaxTree.fs @@ -370,16 +370,16 @@ type SynTyparDecls = | SinglePrefix (range = range) -> range [] -type TupleTypeSegment = +type SynTupleTypeSegment = | Type of typeName: SynType | Star of range: range | Slash of range: range member this.Range = match this with - | TupleTypeSegment.Type t -> t.Range - | TupleTypeSegment.Star (range = range) - | TupleTypeSegment.Slash (range = range) -> range + | SynTupleTypeSegment.Type t -> t.Range + | SynTupleTypeSegment.Star (range = range) + | SynTupleTypeSegment.Slash (range = range) -> range [] type SynType = @@ -404,7 +404,7 @@ type SynType = greaterRange: range option * range: range - | Tuple of isStruct: bool * path: TupleTypeSegment list * range: range + | Tuple of isStruct: bool * path: SynTupleTypeSegment list * range: range | AnonRecd of isStruct: bool * fields: (Ident * SynType) list * range: range diff --git a/src/Compiler/SyntaxTree/SyntaxTree.fsi b/src/Compiler/SyntaxTree/SyntaxTree.fsi index 694632893ca..60815a6df09 100644 --- a/src/Compiler/SyntaxTree/SyntaxTree.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTree.fsi @@ -428,7 +428,7 @@ type SynTyparDecls = member Range: range [] -type TupleTypeSegment = +type SynTupleTypeSegment = | Type of typeName: SynType | Star of range: range | Slash of range: range @@ -465,7 +465,7 @@ type SynType = /// F# syntax: type * ... * type /// F# syntax: struct (type * ... * type) - | Tuple of isStruct: bool * path: TupleTypeSegment list * range: range + | Tuple of isStruct: bool * path: SynTupleTypeSegment list * range: range /// F# syntax: {| id: type; ...; id: type |} /// F# syntax: struct {| id: type; ...; id: type |} diff --git a/src/Compiler/SyntaxTree/SyntaxTreeOps.fs b/src/Compiler/SyntaxTree/SyntaxTreeOps.fs index 7fe33584537..24ffaf78a98 100644 --- a/src/Compiler/SyntaxTree/SyntaxTreeOps.fs +++ b/src/Compiler/SyntaxTree/SyntaxTreeOps.fs @@ -1018,8 +1018,8 @@ let rec desugarGetSetMembers (memberDefns: SynMemberDefns) = [ SynMemberDefn.Interface(interfaceType, withKeyword, members, m) ] | md -> [ md ]) -let getTypeFromTuplePath (path: TupleTypeSegment list) : SynType list = +let getTypeFromTuplePath (path: SynTupleTypeSegment list) : SynType list = path |> List.choose (function - | TupleTypeSegment.Type t -> Some t + | SynTupleTypeSegment.Type t -> Some t | _ -> None) diff --git a/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi b/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi index 4d3879792ba..7af4403fac2 100644 --- a/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi +++ b/src/Compiler/SyntaxTree/SyntaxTreeOps.fsi @@ -345,4 +345,4 @@ val normalizeTupleExpr: exprs: SynExpr list -> commas: range list -> SynExpr lis val desugarGetSetMembers: memberDefns: SynMemberDefns -> SynMemberDefns -val getTypeFromTuplePath: path: TupleTypeSegment list -> SynType list +val getTypeFromTuplePath: path: SynTupleTypeSegment list -> SynType list diff --git a/src/Compiler/pars.fsy b/src/Compiler/pars.fsy index 321d1a4f670..98a75cbeca9 100644 --- a/src/Compiler/pars.fsy +++ b/src/Compiler/pars.fsy @@ -5030,7 +5030,7 @@ topType: topTupleType: | topAppType STAR topTupleTypeElements { let t, argInfo = $1 - let path = TupleTypeSegment.Type t :: (List.map fst $3) + let path = SynTupleTypeSegment.Type t :: (List.map fst $3) let mdata = argInfo :: (List.choose snd $3) mkSynTypeTuple false path, mdata } @@ -5041,11 +5041,11 @@ topTupleTypeElements: | topAppType STAR topTupleTypeElements { let t, argInfo = $1 let mStar = rhs parseState 2 - (TupleTypeSegment.Type t, Some argInfo) :: (TupleTypeSegment.Star mStar, None) :: $3 } + (SynTupleTypeSegment.Type t, Some argInfo) :: (SynTupleTypeSegment.Star mStar, None) :: $3 } | topAppType %prec prec_toptuptyptail_prefix { let t, argInfo = $1 - [ TupleTypeSegment.Type t, Some argInfo ] } + [ SynTupleTypeSegment.Type t, Some argInfo ] } topAppType: | attributes appType COLON appType @@ -5087,19 +5087,19 @@ typEOF: tupleType: | appType STAR tupleOrQuotTypeElements { let mStar = rhs parseState 2 - let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Star mStar :: $3 + let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3 mkSynTypeTuple false path } | INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $1 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); let mSlash = rhs parseState 1 - let path = TupleTypeSegment.Slash mSlash :: $2 + let path = SynTupleTypeSegment.Slash mSlash :: $2 mkSynTypeTuple false path } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); let mSlash = rhs parseState 2 - let path = TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 + let path = SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3 mkSynTypeTuple false path } | appType %prec prec_tuptyp_prefix @@ -5108,15 +5108,15 @@ tupleType: tupleOrQuotTypeElements: | appType STAR tupleOrQuotTypeElements { let mStar = rhs parseState 2 - TupleTypeSegment.Type $1 :: TupleTypeSegment.Star mStar :: $3 } + SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Star mStar :: $3 } | appType INFIX_STAR_DIV_MOD_OP tupleOrQuotTypeElements { if $2 <> "/" then reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnexpectedInfixOperator()); let mSlash = rhs parseState 2 - TupleTypeSegment.Type $1 :: TupleTypeSegment.Slash mSlash :: $3 } + SynTupleTypeSegment.Type $1 :: SynTupleTypeSegment.Slash mSlash :: $3 } | appType %prec prec_tuptyptail_prefix - { [ TupleTypeSegment.Type $1 ] } + { [ SynTupleTypeSegment.Type $1 ] } appTypeCon: | path %prec prec_atomtyp_path @@ -5251,13 +5251,13 @@ atomType: | STRUCT LPAREN appType STAR tupleOrQuotTypeElements rparen { let mStar = rhs parseState 4 - let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 + let path = SynTupleTypeSegment.Type $3 :: SynTupleTypeSegment.Star mStar :: $5 mkSynTypeTuple true path } | STRUCT LPAREN appType STAR tupleOrQuotTypeElements recover { reportParseErrorAt (rhs parseState 2) (FSComp.SR.parsUnmatchedParen()) let mStar = rhs parseState 4 - let path = TupleTypeSegment.Type $3 :: TupleTypeSegment.Star mStar :: $5 + let path = SynTupleTypeSegment.Type $3 :: SynTupleTypeSegment.Star mStar :: $5 mkSynTypeTuple true path } | STRUCT LPAREN appType STAR recover diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected index 7ca04a5d7eb..643f6c7ce3e 100644 --- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected +++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected @@ -8307,6 +8307,34 @@ FSharp.Compiler.Syntax.SynStringKind: Int32 GetHashCode(System.Collections.IEqua FSharp.Compiler.Syntax.SynStringKind: Int32 Tag FSharp.Compiler.Syntax.SynStringKind: Int32 get_Tag() FSharp.Compiler.Syntax.SynStringKind: System.String ToString() +FSharp.Compiler.Syntax.SynTupleTypeSegment +FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range get_range() +FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash: FSharp.Compiler.Text.Range range +FSharp.Compiler.Syntax.SynTupleTypeSegment+Star: FSharp.Compiler.Text.Range get_range() +FSharp.Compiler.Syntax.SynTupleTypeSegment+Star: FSharp.Compiler.Text.Range range +FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Slash +FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Star +FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags: Int32 Type +FSharp.Compiler.Syntax.SynTupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType get_typeName() +FSharp.Compiler.Syntax.SynTupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType typeName +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsSlash +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsStar +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean IsType +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsSlash() +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsStar() +FSharp.Compiler.Syntax.SynTupleTypeSegment: Boolean get_IsType() +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewSlash(FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewStar(FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment NewType(FSharp.Compiler.Syntax.SynType) +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Slash +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Star +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Tags +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Syntax.SynTupleTypeSegment+Type +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Text.Range Range +FSharp.Compiler.Syntax.SynTupleTypeSegment: FSharp.Compiler.Text.Range get_Range() +FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 Tag +FSharp.Compiler.Syntax.SynTupleTypeSegment: Int32 get_Tag() +FSharp.Compiler.Syntax.SynTupleTypeSegment: System.String ToString() FSharp.Compiler.Syntax.SynTypar FSharp.Compiler.Syntax.SynTypar: Boolean get_isCompGen() FSharp.Compiler.Syntax.SynTypar: Boolean isCompGen @@ -8477,8 +8505,8 @@ FSharp.Compiler.Syntax.SynType+Tuple: Boolean get_isStruct() FSharp.Compiler.Syntax.SynType+Tuple: Boolean isStruct FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range get_range() FSharp.Compiler.Syntax.SynType+Tuple: FSharp.Compiler.Text.Range range -FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment] get_path() -FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment] path +FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment] get_path() +FSharp.Compiler.Syntax.SynType+Tuple: Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment] path FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar get_typar() FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Syntax.SynTypar typar FSharp.Compiler.Syntax.SynType+Var: FSharp.Compiler.Text.Range get_range() @@ -8537,7 +8565,7 @@ FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewParen(FSharp.C FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstant(FSharp.Compiler.Syntax.SynConst, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantExpr(FSharp.Compiler.Syntax.SynExpr, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewStaticConstantNamed(FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range) -FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.TupleTypeSegment], FSharp.Compiler.Text.Range) +FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewTuple(Boolean, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTupleTypeSegment], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewVar(FSharp.Compiler.Syntax.SynTypar, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType NewWithGlobalConstraints(FSharp.Compiler.Syntax.SynType, Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynTypeConstraint], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SynType: FSharp.Compiler.Syntax.SynType+Anon @@ -9145,34 +9173,6 @@ FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOptio FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitTypeAbbrev(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], FSharp.Compiler.Syntax.SynType, FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Microsoft.FSharp.Core.FSharpOption`1[T] VisitUnionDefn(Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SyntaxNode], Microsoft.FSharp.Collections.FSharpList`1[FSharp.Compiler.Syntax.SynUnionCase], FSharp.Compiler.Text.Range) FSharp.Compiler.Syntax.SyntaxVisitorBase`1[T]: Void .ctor() -FSharp.Compiler.Syntax.TupleTypeSegment -FSharp.Compiler.Syntax.TupleTypeSegment+Slash: FSharp.Compiler.Text.Range get_range() -FSharp.Compiler.Syntax.TupleTypeSegment+Slash: FSharp.Compiler.Text.Range range -FSharp.Compiler.Syntax.TupleTypeSegment+Star: FSharp.Compiler.Text.Range get_range() -FSharp.Compiler.Syntax.TupleTypeSegment+Star: FSharp.Compiler.Text.Range range -FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Slash -FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Star -FSharp.Compiler.Syntax.TupleTypeSegment+Tags: Int32 Type -FSharp.Compiler.Syntax.TupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType get_typeName() -FSharp.Compiler.Syntax.TupleTypeSegment+Type: FSharp.Compiler.Syntax.SynType typeName -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsSlash -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsStar -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean IsType -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsSlash() -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsStar() -FSharp.Compiler.Syntax.TupleTypeSegment: Boolean get_IsType() -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewSlash(FSharp.Compiler.Text.Range) -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewStar(FSharp.Compiler.Text.Range) -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment NewType(FSharp.Compiler.Syntax.SynType) -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Slash -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Star -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Tags -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Syntax.TupleTypeSegment+Type -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Text.Range Range -FSharp.Compiler.Syntax.TupleTypeSegment: FSharp.Compiler.Text.Range get_Range() -FSharp.Compiler.Syntax.TupleTypeSegment: Int32 Tag -FSharp.Compiler.Syntax.TupleTypeSegment: Int32 get_Tag() -FSharp.Compiler.Syntax.TupleTypeSegment: System.String ToString() FSharp.Compiler.Syntax.TyparStaticReq FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 HeadType FSharp.Compiler.Syntax.TyparStaticReq+Tags: Int32 None diff --git a/tests/service/SyntaxTreeTests/MeasureTests.fs b/tests/service/SyntaxTreeTests/MeasureTests.fs index 73c7825cbd7..0e618693df9 100644 --- a/tests/service/SyntaxTreeTests/MeasureTests.fs +++ b/tests/service/SyntaxTreeTests/MeasureTests.fs @@ -67,9 +67,9 @@ let ``SynType.Tuple in measure type with no slashes`` () = SynTypeDefn(typeRepr = SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = - SynType.Tuple(false, [ TupleTypeSegment.Type (TypeName "Y") - TupleTypeSegment.Star mStar - TupleTypeSegment.Type (TypeName "Z") ], mTuple)))) + SynType.Tuple(false, [ SynTupleTypeSegment.Type (TypeName "Y") + SynTupleTypeSegment.Star mStar + SynTupleTypeSegment.Type (TypeName "Z") ], mTuple)))) ]) ]) ])) -> assertRange (2, 23) (2, 24) mStar @@ -90,8 +90,8 @@ let ``SynType.Tuple in measure type with leading slash`` () = SynTypeDefn(typeRepr = SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = - SynType.Tuple(false, [ TupleTypeSegment.Slash mSlash - TupleTypeSegment.Type (TypeName "second") ], mTuple)))) + SynType.Tuple(false, [ SynTupleTypeSegment.Slash mSlash + SynTupleTypeSegment.Type (TypeName "second") ], mTuple)))) ]) ]) ])) -> assertRange (2, 21) (2, 22) mSlash @@ -112,11 +112,11 @@ let ``SynType.Tuple in measure type with start and slash`` () = SynTypeDefn(typeRepr = SynTypeDefnRepr.Simple(simpleRepr = SynTypeDefnSimpleRepr.TypeAbbrev(rhsType = - SynType.Tuple(false, [ TupleTypeSegment.Type (TypeName "X") - TupleTypeSegment.Star msStar - TupleTypeSegment.Type (TypeName "Y") - TupleTypeSegment.Slash msSlash - TupleTypeSegment.Type (TypeName "Z") ], mTuple)))) + SynType.Tuple(false, [ SynTupleTypeSegment.Type (TypeName "X") + SynTupleTypeSegment.Star msStar + SynTupleTypeSegment.Type (TypeName "Y") + SynTupleTypeSegment.Slash msSlash + SynTupleTypeSegment.Type (TypeName "Z") ], mTuple)))) ]) ]) ])) -> assertRange (2, 23) (2, 24) msStar