Upstream a bunch of tests

See https://github.com/dhall-lang/dhall-lang/pull/698

1 files changed, 6 insertions, 99 deletions

diff --git a/tests_buffer b/tests_buffer
index ca578e4..4f8a375 100644
--- a/tests_buffer
+++ b/tests_buffer
@@ -2,90 +2,13 @@ parser:
 ./a%20b
 ./"a%20b"
 text interpolation and escapes
-remove `double`
-remove imports/parenthesizeUsing
-remove multilet
-selection by expression unit tests
-split aslocation test into actual unit tests
+projection by expression unit tests
 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 }
+    AssertNoAnnotation assert
 
 binary decoding:
 decode old-style optional literals ?
@@ -99,39 +22,23 @@ failure/
 
 normalization:
 variables across import boundaries
-Text/show ""
-Double/show -1.5e-10
+    Text/show ""
+    Double/show -1.5e-10
     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:
 something that involves destructuring a recordtype after merge
 add some of the more complicated Prelude tests back, like List/enumerate
 failure on old-style optional literal
-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) -> _
+    MergeBoolIsNotUnion merge x True
+    MergeOptionalIsNotUnion merge x (Some 1)
 
 equivalence: