Update test buffer

1 files changed, 113 insertions, 97 deletions

diff --git a/tests_buffer b/tests_buffer
index 05fc4bd..75a233b 100644
--- a/tests_buffer
+++ b/tests_buffer
@@ -1,113 +1,129 @@
 parser:
-x.{ y: T }
 ./a%20b
 ./"a%20b"
 text interpolation and escapes
 remove `double`
-rename imports/parenthesizeUsing
-imports/
-    Missing missing
-    Headers https://example.com/foo using ./headers
-    HeadersHashPrecedence https://example.com/foo using ./headers sha256:0000000000000000000000000000000000000000000000000000000000000000
-    HeadersHash https://example.com/foo using (./headers sha256:0000000000000000000000000000000000000000000000000000000000000000)
-operator precedence
-DoubleLitPositive 1.23
-DoubleLitNegative -1.23
-DoubleLitExponent 1.23e4
-DoubleLitExponentNoDot 1e4
-DoubleLitExponentNegative 1.23e-4
-DoubleLitInfinity Infinity
-DoubleLitNegInfinity -Infinity
-DoubleLitNaN NaN
-DoubleLitSecretelyInt 1.0
-DoubleLitZero 0.0
-BuiltinListBuild List/Build
-FunctionApplicationOneArg f x
-FunctionApplicationMultipleArgs f x y z
-Annotation x : T
-ListLitNonEmpty [x, y]
-ListLitNonEmptyAnnotated [x, y] : List T
-OptionalLitEmpty []: Optional T
-OptionalLitNonEmpty [x]: Optional T
-Field r.x
-FieldBuiltinName r.List
-FieldQuoted r.`x`
-Projection r.{x, y, z}
-Let let x: T = v in e
-LetNested let x: T = v in let y: U = w in e
-LetMulti let x: T = v let y: U = w in e
-LambdaUnicode λ(x : T) -> y
-FunctionTypePi forall(x: T) -> U
-FunctionTypePiUnicode ∀(x: T) -> U
-FunctionTypePiNested forall(x: T) -> forall(y: U) -> V
-FunctionTypePiUnderscore forall(_: T) -> U
-FunctionTypeArrow T -> U
-RecordLit {x = 1, y = 2}
-RecordType {x: T, y: U}
-OperatorBoolOr x || y
-OperatorBoolOrAssoc w || x || y || z
-OperatorImportAlt x ? y
-OperatorImportAltAssoc w ? x ? y ? z
-OperatorNaturalPlus x + y
-OperatorNaturalPlusAssoc w + x + y + z
-OperatorTextAppend x ++ y
-OperatorTextAppendAssoc w ++ x ++ y ++ z
-OperatorListAppend x # y
-OperatorListAppendAssoc w # x # y # z
-OperatorBoolAnd x && y
-OperatorBoolAndAssoc w && x && y && z
-OperatorNaturalTimes x * y
-OperatorNaturalTimesAssoc w * x * y * z
-OperatorBoolEQ x == y
-OperatorBoolEQAssoc w == x == y == z
-OperatorBoolNE x != y
-OperatorBoolNEAssoc w != x != y != z
-OperatorRecursiveRecordMerge x //\\ y
-OperatorRecursiveRecordMergeAssoc w //\\ x //\\ y //\\ z
-OperatorRecursiveRecordTypeMerge x /\ y
-OperatorRecursiveRecordTypeMergeAssoc w /\ x /\ y /\ z
-OperatorRightBiasedRecordMerge x // y
-OperatorRightBiasedRecordMergeAssoc w // x // y // z
-OperatorRecursiveRecordMergeUnicode x ∧ y
-OperatorRecursiveRecordMergeUnicodeAssoc w ∧ x /\ y ∧ z
-OperatorRightBiasedRecordMergeUnicode x ⫽ y
-OperatorRightBiasedRecordMergeUnicodeAssoc w ⫽ x // y ⫽ z
-OperatorRecursiveRecordTypeMergeUnicode x ⩓ y
-OperatorRecursiveRecordTypeMergeUnicodeAssoc w ⩓ x //\\ y ⩓ z
+remove imports/parenthesizeUsing
+remove multilet
+success/
+    imports/
+        Missing missing
+        Headers https://example.com/foo using ./headers
+        HeadersInteriorHash https://example.com/foo using (./headers sha256:0000000000000000000000000000000000000000000000000000000000000000)
+        HeadersExteriorHash (https://example.com/foo using ./headers) sha256:0000000000000000000000000000000000000000000000000000000000000000
+        HeadersHashPrecedence https://example.com/foo using ./headers sha256:0000000000000000000000000000000000000000000000000000000000000000
+        HeadersDoubleHashPrecedence https://example.com/foo using ./headers sha256:0000000000000000000000000000000000000000000000000000000000000000 sha256:1111111111111111111111111111111111111111111111111111111111111111
+    DoubleLitPositive 1.23
+    DoubleLitNegative -1.23
+    DoubleLitExponent 1.23e4
+    DoubleLitExponentNoDot 1e4
+    DoubleLitExponentNegative 1.23e-4
+    DoubleLitInfinity Infinity
+    DoubleLitNegInfinity -Infinity
+    DoubleLitNaN NaN
+    DoubleLitSecretelyInt 1.0
+    DoubleLitZero 0.0
+    BuiltinListBuild List/Build
+    FunctionApplicationOneArg f x
+    FunctionApplicationMultipleArgs f x y z
+    Annotation x : T
+    ListLitNonEmpty [x, y]
+    ListLitNonEmptyAnnotated [x, y] : List T
+    OptionalLitEmpty []: Optional T
+    OptionalLitNonEmpty [x]: Optional T
+    Field r.x
+    FieldBuiltinName r.List
+    FieldQuoted r.`x`
+    Projection r.{x, y, z}
+    Let let x: T = v in e
+    LetNested let x: T = v in let y: U = w in e
+    LetMulti let x: T = v let y: U = w in e
+    LambdaUnicode λ(x : T) -> y
+    FunctionTypePi forall(x: T) -> U
+    FunctionTypePiUnicode ∀(x: T) -> U
+    FunctionTypePiNested forall(x: T) -> ∀(y: U) -> V
+    FunctionTypePiUnderscore forall(_: T) -> U
+    FunctionTypeArrow T -> U
+    RecordLit { x = 1, y = 2 }
+    RecordType { x: T, y: U }
+    operators/
+        ImportAlt x ? y
+        ImportAltAssoc w ? x ? y ? z
+        BoolOr x || y
+        BoolOrAssoc w || x || y || z
+        NaturalPlus x + y
+        NaturalPlusAssoc w + x + y + z
+        TextAppend x ++ y
+        TextAppendAssoc w ++ x ++ y ++ z
+        ListAppend x # y
+        ListAppendAssoc w # x # y # z
+        BoolAnd x && y
+        BoolAndAssoc w && x && y && z
+        NaturalTimes x * y
+        NaturalTimesAssoc w * x * y * z
+        BoolEQ x == y
+        BoolEQAssoc w == x == y == z
+        BoolNE x != y
+        BoolNEAssoc w != x != y != z
+        RecursiveRecordMerge x //\\ y
+        RecursiveRecordMergeAssoc w //\\ x //\\ y //\\ z
+        RecursiveRecordTypeMerge x /\ y
+        RecursiveRecordTypeMergeAssoc w /\ x /\ y /\ z
+        RightBiasedRecordMerge x // y
+        RightBiasedRecordMergeAssoc w // x // y // z
+        RecursiveRecordMergeUnicode x ∧ y
+        RecursiveRecordMergeUnicodeAssoc w ∧ x /\ y ∧ z
+        RightBiasedRecordMergeUnicode x ⫽ y
+        RightBiasedRecordMergeUnicodeAssoc w ⫽ x // y ⫽ z
+        RecursiveRecordTypeMergeUnicode x ⩓ y
+        RecursiveRecordTypeMergeUnicodeAssoc w ⩓ x //\\ y ⩓ z
+        PrecedenceAll1 a ? b || c + d ++ e # f && g ∧ h ⫽ i ⩓ j * k == l != m n.o
+        PrecedenceAll2 a b != c == d * e ⩓ f ⫽ g ∧ h && i # j ++ k + l || m ? n
+        PrecedenceNat a + b * d + e f * (g + h)
+        PrecedenceBool a && b || c d == e || f != g && h || i
+        PrecedenceRecord a // b c /\ d ⫽ e.{x} ∧ f
+failure/
+    ProjectionByExpressionNeedsParens r.{ x: T }
 
 
 import:
-recover type error
-recover recursive import error
-don't recover cycle
+success/
+    recover type error
+    recover recursive import error
+failure/
+    don't recover cycle
 
 normalization:
 variables across import boundaries
-"${"${x}"}"
-"${"${""}"}${x}"
-"${""}${x}"
+    TextLitNested1 "${""}${x}"
+    TextLitNested2 "${"${x}"}"
+    TextLitNested3 "${"${""}"}${x}"
+    EquivalenceDouble if b then NaN else NaN
+    EquivalenceAlpha if b then \(x: T) -> x else \(y: T) -> y
 
 typecheck:
-(merge {} <>) : Bool
-merge x True
-merge x (Some 1)
-let x: T = merge x y in ...
-let _ = Bool in merge {foo = \(x: _) -> x} <foo: Bool>.foo
-let foo = Bool in merge {foo = \(x: foo) -> x} <foo: Bool>.foo
-merge { x = 1 } < x >.x
-merge {=} < x >.x
-merge { x = λ(_ : Bool) → _, y = 1 } < x = True | y >
-merge { x = True, y = 1 } < x | y >.x
-merge {x=...,y=...} <x>.x
-merge {x=...,} <x|y>.x
-merge {x=...,y=...} <x:T>.x
-merge {x=...,} <x:T|y:T>.x
-merge { x = None } < x = Bool >
-<x, x>
-<x, x:T>
-<x=1|x:T>
-{ x: T, x: T }
 something that involves destructuring a recordtype after merge
+success/
+    MergeEmptyAlternative merge { x = 1 } < x >.x
+    MergeTrickyShadowing let _ = Bool in merge {_ = \(x: _) -> x} (<_: Bool>._ True)
+    EquivalenceAlpha \(TODO: forall(x: Type) -> x) -> TODO : forall(y: Type) -> y
+failure/
+    MergeEmptyNeedsDirectAnnotation1 \(x: <>) -> (merge {=} x) : Bool
+    MergeEmptyNeedsDirectAnnotation2 \(x: <>) -> let y: Bool = merge {=} x in 1
+    MergeBoolIsNotUnion merge x True
+    MergeOptionalIsNotUnion merge x (Some 1)
+    MergeMissingHandler1 merge {=} < x >.x
+    MergeMissingHandler2 merge {x=...,} <x|y>.x
+    merge { x = λ(x : Bool) → x } (< x: Bool | y: Natural >.x True)
+    merge { x = λ(_ : Bool) → _, y = 1 } < x = True | y >
+    merge { x = True, y = 1 } < x | y >.x
+    merge {x=...,y=...} <x>.x
+    merge {x=...,y=...} <x:T>.x
+    MergeHandlerFreeVar merge { x = None } < x = Bool >
+    UnionTypeDuplicateVariants1 <x, x>
+    UnionTypeDuplicateVariants2 <x, x:T>
+    UnionLitDuplicateVariants <x=1|x:T>
+    RecordLitDuplicateFields { x: T, x: T }
+    EquivalenceAlphaTrap \(TODO: forall(_: Type) -> _) -> TODO : forall(x: Type) -> _
 
 equivalence:
-forall(x: T) -> x = forall(x: T) -> y