From 13265c95fcacf9952bc61ebece64078d8b6124ec Mon Sep 17 00:00:00 2001 From: Eduardo Julian Date: Sat, 11 Aug 2018 10:00:48 -0400 Subject: Got stdlib tests to compile again. --- .../lux/compiler/default/phase/analysis/case.lux | 2 +- .../compiler/default/phase/analysis/function.lux | 22 ++++----- .../compiler/default/phase/analysis/primitive.lux | 19 +++++--- .../default/phase/analysis/procedure/common.lux | 4 +- .../compiler/default/phase/analysis/reference.lux | 12 ++--- .../compiler/default/phase/analysis/structure.lux | 52 +++++++++++----------- 6 files changed, 59 insertions(+), 52 deletions(-) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux index abe199241..2b9cfa914 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/case.lux @@ -168,7 +168,7 @@ (list (let [[_pattern _body] (maybe.assume (list.nth heterogeneous-idx exhaustive-branchesC))] [_pattern heterogeneousC])) (list.drop (inc heterogeneous-idx) exhaustive-branchesC))) - analyse-pm (|>> (/.case _primitive.analyse inputC) + analyse-pm (|>> (/.case _primitive.phase inputC) (typeA.with-type outputT) analysis.with-scope (do phase.Monad diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux index 5cf5b232a..e9d1c6f8e 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/function.lux @@ -36,7 +36,7 @@ (-> Type Nat (Operation Analysis) Bit) (|> analysis (typeA.with-type expectedT) - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run _primitive.state) (case> (#e.Success applyA) (let [[funcA argsA] (analysis.application applyA)] (n/= num-args (list.size argsA))) @@ -55,21 +55,21 @@ ($_ seq (test "Can analyse function." (and (|> (typeA.with-type (All [a] (-> a outputT)) - (/.function _primitive.analyse func-name arg-name outputC)) + (/.function _primitive.phase func-name arg-name outputC)) _structure.check-succeeds) (|> (typeA.with-type (All [a] (-> a a)) - (/.function _primitive.analyse func-name arg-name g!arg)) + (/.function _primitive.phase func-name arg-name g!arg)) _structure.check-succeeds))) (test "Generic functions can always be specialized." (and (|> (typeA.with-type (-> inputT outputT) - (/.function _primitive.analyse func-name arg-name outputC)) + (/.function _primitive.phase func-name arg-name outputC)) _structure.check-succeeds) (|> (typeA.with-type (-> inputT inputT) - (/.function _primitive.analyse func-name arg-name g!arg)) + (/.function _primitive.phase func-name arg-name g!arg)) _structure.check-succeeds))) (test "The function's name is bound to the function's type." (|> (typeA.with-type (Rec self (-> inputT self)) - (/.function _primitive.analyse func-name arg-name (code.local-identifier func-name))) + (/.function _primitive.phase func-name arg-name (code.local-identifier func-name))) _structure.check-succeeds)) )))) @@ -101,18 +101,18 @@ dummy-function (#analysis.Function (list) (#analysis.Reference (reference.local 1)))]] ($_ seq (test "Can analyse monomorphic type application." - (|> (/.apply _primitive.analyse funcT dummy-function inputsC) + (|> (/.apply _primitive.phase funcT dummy-function inputsC) (check-apply outputT full-args))) (test "Can partially apply functions." - (|> (/.apply _primitive.analyse funcT dummy-function (list.take partial-args inputsC)) + (|> (/.apply _primitive.phase funcT dummy-function (list.take partial-args inputsC)) (check-apply partialT partial-args))) (test "Can apply polymorphic functions." - (|> (/.apply _primitive.analyse polyT dummy-function inputsC) + (|> (/.apply _primitive.phase polyT dummy-function inputsC) (check-apply poly-inputT full-args))) (test "Polymorphic partial application propagates found type-vars." - (|> (/.apply _primitive.analyse polyT dummy-function (list.take (inc var-idx) inputsC)) + (|> (/.apply _primitive.phase polyT dummy-function (list.take (inc var-idx) inputsC)) (check-apply partial-polyT1 (inc var-idx)))) (test "Polymorphic partial application preserves quantification for type-vars." - (|> (/.apply _primitive.analyse polyT dummy-function (list.take var-idx inputsC)) + (|> (/.apply _primitive.phase polyT dummy-function (list.take var-idx inputsC)) (check-apply partial-polyT2 var-idx))) )))) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux index 85e5660b0..6a64cc206 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/primitive.lux @@ -16,7 +16,8 @@ [compiler [default ["." init] - ["." phase (#+ Eval) + [evaluation (#+ Eval)] + ["." phase ["." analysis (#+ Analysis Operation) [".A" type] ["." expression]] @@ -24,7 +25,13 @@ [".E" analysis]]]]] test]) -(def: #export analyse (expression.analyser (:coerce Eval []))) +(def: #export phase + analysis.Phase + expression.compile) + +(def: #export state + analysis.State+ + [(analysisE.bundle (:coerce Eval [])) (init.compiler [])]) (def: unit (r.Random Code) @@ -37,7 +44,7 @@ [(r.and (random/wrap ) (random/map ))] [Any code.tuple (r.list 0 ..unit)] - [Bit code.bit r.bit] + [Bit code.bit r.bit] [Nat code.nat r.nat] [Int code.int r.int] [Rev code.rev r.rev] @@ -53,7 +60,7 @@ (-> Type (Operation Analysis) (e.Error Analysis)) (|> analysis typeA.with-inference - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run ..state) (case> (#e.Success [inferred-type output]) (if (is? expected-type inferred-type) (#e.Success output) @@ -65,7 +72,7 @@ (context: "Primitives" ($_ seq (test "Can analyse unit." - (|> (infer-primitive Any (..analyse (' []))) + (|> (infer-primitive Any (..phase (' []))) (case> (^ (#e.Success (#analysis.Primitive (#analysis.Unit output)))) (is? [] output) @@ -77,7 +84,7 @@ [(do @ [sample ] (test (format "Can analyse " ".") - (|> (infer-primitive (..analyse ( sample))) + (|> (infer-primitive (..phase ( sample))) (case> (#e.Success (#analysis.Primitive ( output))) (is? sample output) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux index 20eeaf2eb..fc082155a 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/procedure/common.lux @@ -34,8 +34,8 @@ (-> Text (List Code) Type Bit) (|> (scope.with-scope "" (typeA.with-type output-type - (_primitive.analyse (` ((~ (code.text procedure)) (~+ params)))))) - (phase.run [analysisE.bundle (init.compiler [])]) + (_primitive.phase (` ((~ (code.text procedure)) (~+ params)))))) + (phase.run _primitive.state) (case> (#e.Success _) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux index a78d1b236..8aed9e39b 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/reference.lux @@ -58,8 +58,8 @@ (module.import def-module) (wrap []))] (typeA.with-inference - (_primitive.analyse (code.identifier [def-module var-name])))))) - (phase.run [analysisE.bundle (init.compiler [])]) + (_primitive.phase (code.identifier [def-module var-name])))))) + (phase.run _primitive.state) check!)) (context: "References" @@ -76,8 +76,8 @@ (|> (scope.with-scope scope-name (scope.with-local [var-name expectedT] (typeA.with-inference - (_primitive.analyse (code.local-identifier var-name))))) - (phase.run [analysisE.bundle (init.compiler [])]) + (_primitive.phase (code.local-identifier var-name))))) + (phase.run _primitive.state) (case> (^ (#e.Success [inferredT (#analysis.Reference (reference.local var))])) (and (type/= expectedT inferredT) (n/= 0 var)) @@ -89,9 +89,9 @@ (|> (do phase.Monad [_ (module.define var-name [expectedT (' {}) []])] (typeA.with-inference - (_primitive.analyse (code.identifier def-name)))) + (_primitive.phase (code.identifier def-name)))) (module.with-module 0 def-module) - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run _primitive.state) (case> (^ (#e.Success [_ inferredT (#analysis.Reference (reference.constant constant-name))])) (and (type/= expectedT inferredT) (name/= def-name constant-name)) diff --git a/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux b/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux index 92f92e54e..9a17deaec 100644 --- a/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux +++ b/stdlib/test/test/lux/compiler/default/phase/analysis/structure.lux @@ -36,7 +36,7 @@ (do-template [ ] [(def: #export (All [a] (-> (Operation a) Bit)) - (|>> (phase.run [analysisE.bundle (init.compiler [])]) + (|>> (phase.run _primitive.state) (case> (#e.Success _) @@ -60,7 +60,7 @@ (-> Type Nat Tag (Operation Analysis) Bit) (|> analysis (typeA.with-type type) - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run _primitive.state) (case> (^multi (#e.Success sumA) [(analysis.variant sumA) (#.Some variant)]) @@ -80,7 +80,7 @@ (|> analysis (tagged module tags type) (typeA.with-type type) - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run _primitive.state) (case> (^multi (#e.Success [_ sumA]) [(analysis.variant sumA) (#.Some variant)]) @@ -97,7 +97,7 @@ (-> Text (List module.Tag) Type Nat (Operation [Type Analysis]) Bit) (|> analysis (tagged module tags type) - (phase.run [analysisE.bundle (init.compiler [])]) + (phase.run _primitive.state) (case> (#e.Success [_ productT productA]) (and (type/= type productT) (right-size? size productA)) @@ -124,15 +124,15 @@ ($_ seq (test "Can analyse sum." (check-sum variantT size choice - (/.sum _primitive.analyse choice valueC))) + (/.sum _primitive.phase choice valueC))) (test "Can analyse sum through bound type-vars." (|> (do phase.Monad [[_ varT] (typeA.with-env check.var) _ (typeA.with-env (check.check varT variantT))] (typeA.with-type varT - (/.sum _primitive.analyse choice valueC))) - (phase.run [analysisE.bundle (init.compiler [])]) + (/.sum _primitive.phase choice valueC))) + (phase.run _primitive.state) (case> (^multi (#e.Success sumA) [(analysis.variant sumA) (#.Some variant)]) @@ -144,18 +144,18 @@ (|> (do phase.Monad [[_ varT] (typeA.with-env check.var)] (typeA.with-type varT - (/.sum _primitive.analyse choice valueC))) + (/.sum _primitive.phase choice valueC))) check-fails)) (test "Can analyse sum through existential quantification." (|> (typeA.with-type (type.ex-q 1 +variantT) - (/.sum _primitive.analyse +choice +valueC)) + (/.sum _primitive.phase +choice +valueC)) check-succeeds)) (test "Can analyse sum through universal quantification." (let [check-outcome (if (not (n/= choice +choice)) check-succeeds check-fails)] (|> (typeA.with-type (type.univ-q 1 +variantT) - (/.sum _primitive.analyse +choice +valueC)) + (/.sum _primitive.phase +choice +valueC)) check-outcome))) )))) @@ -175,8 +175,8 @@ ($_ seq (test "Can analyse product." (|> (typeA.with-type tupleT - (/.product _primitive.analyse (list/map product.right primitives))) - (phase.run [analysisE.bundle (init.compiler [])]) + (/.product _primitive.phase (list/map product.right primitives))) + (phase.run _primitive.state) (case> (#e.Success tupleA) (right-size? size tupleA) @@ -184,8 +184,8 @@ #0))) (test "Can infer product." (|> (typeA.with-inference - (/.product _primitive.analyse (list/map product.right primitives))) - (phase.run [analysisE.bundle (init.compiler [])]) + (/.product _primitive.phase (list/map product.right primitives))) + (phase.run _primitive.state) (case> (#e.Success [_type tupleA]) (and (type/= tupleT _type) (right-size? size tupleA)) @@ -194,7 +194,7 @@ #0))) (test "Can analyse pseudo-product (singleton tuple)" (|> (typeA.with-type singletonT - (_primitive.analyse (` [(~ singletonC)]))) + (_primitive.phase (` [(~ singletonC)]))) check-succeeds)) (test "Can analyse product through bound type-vars." (|> (do phase.Monad @@ -202,8 +202,8 @@ _ (typeA.with-env (check.check varT (type.tuple (list/map product.left primitives))))] (typeA.with-type varT - (/.product _primitive.analyse (list/map product.right primitives)))) - (phase.run [analysisE.bundle (init.compiler [])]) + (/.product _primitive.phase (list/map product.right primitives)))) + (phase.run _primitive.state) (case> (#e.Success tupleA) (right-size? size tupleA) @@ -211,11 +211,11 @@ #0))) (test "Can analyse product through existential quantification." (|> (typeA.with-type (type.ex-q 1 +tupleT) - (/.product _primitive.analyse (list/map product.right +primitives))) + (/.product _primitive.phase (list/map product.right +primitives))) check-succeeds)) (test "Cannot analyse product through universal quantification." (|> (typeA.with-type (type.univ-q 1 +tupleT) - (/.product _primitive.analyse (list/map product.right +primitives))) + (/.product _primitive.phase (list/map product.right +primitives))) check-fails)) )))) @@ -244,17 +244,17 @@ other-choice-tag (maybe.assume (list.nth other-choice tags))]] ($_ seq (test "Can infer tagged sum." - (|> (/.tagged-sum _primitive.analyse [module-name choice-tag] choiceC) + (|> (/.tagged-sum _primitive.phase [module-name choice-tag] choiceC) (check-variant module-name tags namedT choice size))) (test "Tagged sums specialize when type-vars get bound." - (|> (/.tagged-sum _primitive.analyse [module-name choice-tag] choiceC) + (|> (/.tagged-sum _primitive.phase [module-name choice-tag] choiceC) (check-variant module-name tags named-polyT choice size))) (test "Tagged sum inference retains universal quantification when type-vars are not bound." - (|> (/.tagged-sum _primitive.analyse [module-name other-choice-tag] other-choiceC) + (|> (/.tagged-sum _primitive.phase [module-name other-choice-tag] other-choiceC) (check-variant module-name tags named-polyT other-choice size))) (test "Can specialize generic tagged sums." (|> (typeA.with-type variantT - (/.tagged-sum _primitive.analyse [module-name other-choice-tag] other-choiceC)) + (/.tagged-sum _primitive.phase [module-name other-choice-tag] other-choiceC)) (check-variant module-name tags named-polyT other-choice size))) )))) @@ -282,16 +282,16 @@ ($_ seq (test "Can infer record." (|> (typeA.with-inference - (/.record _primitive.analyse recordC)) + (/.record _primitive.phase recordC)) (check-record-inference module-name tags namedT size))) (test "Records specialize when type-vars get bound." (|> (typeA.with-inference - (/.record _primitive.analyse recordC)) + (/.record _primitive.phase recordC)) (check-record-inference module-name tags named-polyT size))) (test "Can specialize generic records." (|> (do phase.Monad [recordA (typeA.with-type tupleT - (/.record _primitive.analyse recordC))] + (/.record _primitive.phase recordC))] (wrap [tupleT recordA])) (check-record-inference module-name tags named-polyT size))) )))) -- cgit v1.2.3