Overview
| Comment: | Prepare data structures and add test for returning modules to load from qualifier step. |
|---|---|
| Timelines: | family | ancestors | descendants | both | modules |
| Files: | files | file ages | folders |
| SHA3-256: |
a7c9bebc321bb95e27b0102ef93ac19a |
| User & Date: | robin.hansen on 2021-02-09 09:40:10 |
| Other Links: | branch diff | manifest | tags |
Context
|
2021-02-09
| ||
| 11:27 | Turn tuple into record in preperation of registering words which requires loading additional modules... check-in: 7eff2f2dbd user: robin.hansen tags: modules | |
| 09:40 | Prepare data structures and add test for returning modules to load from qualifier step. check-in: a7c9bebc32 user: robin.hansen tags: modules | |
|
2021-02-07
| ||
| 12:02 | Qualify member types of structs. check-in: e503e3ec36 user: robin.hansen tags: modules | |
Changes
Modified src/Play/Qualifier.elm from [661a5ac53d] to [caaf815568].
11
12
13
14
15
16
17
18
19
20
21
22
23
24
..
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
import Result.Extra as Result
import Set exposing (Set)
type alias AST =
{ types : Dict String TypeDefinition
, words : Dict String WordDefinition
}
type TypeDefinition
= CustomTypeDef String SourceLocationRange (List String) (List ( String, Type ))
| UnionTypeDef String SourceLocationRange (List String) (List Type)
................................................................................
Dict.foldl (\_ val acc -> qualifyDefinition config qualifiedTypes val acc) ( [], Dict.empty ) config.ast.words
in
case ( typeErrors, wordErrors ) of
( [], [] ) ->
Ok
{ types = qualifiedTypes
, words = qualifiedWords
}
_ ->
Err <| typeErrors ++ wordErrors
resolveUnionInTypeDefs : Dict String TypeDefinition -> TypeDefinition -> TypeDefinition
|
>
>
>
>
>
>
|
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
..
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
import Result.Extra as Result
import Set exposing (Set)
type alias AST =
{ types : Dict String TypeDefinition
, words : Dict String WordDefinition
, additionalModulesRequired : Set String
, checkForExistingTypes : Set String
, checkForExistingWords : Set String
}
type TypeDefinition
= CustomTypeDef String SourceLocationRange (List String) (List ( String, Type ))
| UnionTypeDef String SourceLocationRange (List String) (List Type)
................................................................................
Dict.foldl (\_ val acc -> qualifyDefinition config qualifiedTypes val acc) ( [], Dict.empty ) config.ast.words
in
case ( typeErrors, wordErrors ) of
( [], [] ) ->
Ok
{ types = qualifiedTypes
, words = qualifiedWords
, additionalModulesRequired = Set.empty
, checkForExistingTypes = Set.empty
, checkForExistingWords = Set.empty
}
_ ->
Err <| typeErrors ++ wordErrors
resolveUnionInTypeDefs : Dict String TypeDefinition -> TypeDefinition -> TypeDefinition
|
Modified src/Play/TypeChecker.elm from [fec5dbde4e] to [2a58b70563].
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
...
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
type StackEffect
= Push Type
| Pop Type
initContext : Qualifier.AST -> Context
initContext ast =
let
concreteTypes =
Dict.map
(\_ t ->
case t of
Qualifier.CustomTypeDef name range generics members ->
................................................................................
, boundGenerics = Dict.empty
, boundStackRanges = Dict.empty
, callStack = Set.empty
, errors = List.concatMap genericErrors (Dict.values concreteTypes)
}
run : Qualifier.AST -> Result (List Problem) AST
run ast =
typeCheckHelper (initContext ast) ast
typeCheckHelper : Context -> Qualifier.AST -> Result (List Problem) AST
typeCheckHelper context ast =
let
updatedContext =
Dict.foldl (\_ v acc -> typeCheckDefinition v acc) context ast.words
in
if List.isEmpty updatedContext.errors then
Ok <|
|
|
>
>
>
>
>
>
>
|
|
|
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
...
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
type StackEffect
= Push Type
| Pop Type
type alias LoadedQualifierAST a =
{ a
| types : Dict String Qualifier.TypeDefinition
, words : Dict String Qualifier.WordDefinition
}
initContext : LoadedQualifierAST a -> Context
initContext ast =
let
concreteTypes =
Dict.map
(\_ t ->
case t of
Qualifier.CustomTypeDef name range generics members ->
................................................................................
, boundGenerics = Dict.empty
, boundStackRanges = Dict.empty
, callStack = Set.empty
, errors = List.concatMap genericErrors (Dict.values concreteTypes)
}
run : LoadedQualifierAST a -> Result (List Problem) AST
run ast =
typeCheckHelper (initContext ast) ast
typeCheckHelper : Context -> LoadedQualifierAST a -> Result (List Problem) AST
typeCheckHelper context ast =
let
updatedContext =
Dict.foldl (\_ v acc -> typeCheckDefinition v acc) context ast.words
in
if List.isEmpty updatedContext.errors then
Ok <|
|
Modified tests/Test/Qualifier.elm from [b90b645b36] to [878063bcf2].
850 851 852 853 854 855 856 857 |
SoloImpl
[ GetMember "/play/test/some/module/Cent" "cent-value" ]
}
]
}
in
QualifierUtil.expectModuleOutput unqualifiedAst expectedAst
]
|
> > > > > > > > > > > > > > | > > > > > > > > > > |
850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 |
SoloImpl
[ GetMember "/play/test/some/module/Cent" "cent-value" ]
}
]
}
in
QualifierUtil.expectModuleOutput unqualifiedAst expectedAst
, describe "Module loading"
[ test "Detects external reference in simple word" <|
\_ ->
let
unqualifiedAst =
{ types = Dict.empty
, words =
Dict.fromListBy .name
[ { name = "call-external"
, metadata = Metadata.default
, implementation =
AST.SoloImpl
[ AST.Integer emptyRange 1
, AST.ExternalWord emptyRange [ "external", "module" ] "sample"
]
}
]
}
in
QualifierUtil.expectModuleRequirements unqualifiedAst
[ "/external/module" ]
[]
[ "/external/module/sample" ]
]
]
|
Modified tests/Test/Qualifier/Util.elm from [14665d6907] to [d0efb594d1].
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 .. 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 .. 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
module Test.Qualifier.Util exposing
( addFunctionsForStructs
, expectModuleOutput
, expectOutput
)
import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Play.Data.Metadata as Metadata
import Play.Data.Type as Type exposing (Type)
import Play.Parser as Parser
import Play.Qualifier as AST exposing (AST)
import Play.Qualifier.Problem exposing (Problem)
expectOutput : Parser.AST -> AST -> Expectation
expectOutput parserAst expectedAst =
let
result =
AST.run
{ packageName = ""
, modulePath = ""
, ast = parserAst
................................................................................
}
in
case result of
Err errors ->
Expect.fail <| "Did not expect qualification to fail. Errors: " ++ Debug.toString errors
Ok actualAst ->
Expect.equal expectedAst actualAst
expectModuleOutput : Parser.AST -> AST -> Expectation
expectModuleOutput parserAst expectedAst =
let
result =
AST.run
{ packageName = "play/test"
, modulePath = "some/module"
, ast = parserAst
................................................................................
}
in
case result of
Err errors ->
Expect.fail <| "Did not expect qualification to fail. Errors: " ++ Debug.toString errors
Ok actualAst ->
Expect.equal expectedAst actualAst
addFunctionsForStructs : AST -> AST
addFunctionsForStructs ast =
let
helper _ t wipAst =
case t of
AST.CustomTypeDef name _ generics members ->
addFunctionsForStructsHelper name generics members wipAst
_ ->
wipAst
in
Dict.foldl helper ast ast.types
addFunctionsForStructsHelper : String -> List String -> List ( String, Type ) -> AST -> AST
addFunctionsForStructsHelper name generics members ast =
let
selfType =
if List.isEmpty generics then
Type.Custom name
else
|
> | | > > > > > > > | | > > | > | | > > | > > > > > > > > > > > > > > > > > > > > > > > > > > > | | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 .. 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 .. 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 |
module Test.Qualifier.Util exposing
( addFunctionsForStructs
, expectModuleOutput
, expectModuleRequirements
, expectOutput
)
import Dict exposing (Dict)
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Play.Data.Metadata as Metadata
import Play.Data.Type as Type exposing (Type)
import Play.Parser as Parser
import Play.Qualifier as AST exposing (AST, TypeDefinition, WordDefinition)
import Play.Qualifier.Problem exposing (Problem)
import Set
type alias FullyLoadedAST =
{ types : Dict String TypeDefinition
, words : Dict String WordDefinition
}
expectOutput : Parser.AST -> FullyLoadedAST -> Expectation
expectOutput parserAst expectedAst =
let
result =
AST.run
{ packageName = ""
, modulePath = ""
, ast = parserAst
................................................................................
}
in
case result of
Err errors ->
Expect.fail <| "Did not expect qualification to fail. Errors: " ++ Debug.toString errors
Ok actualAst ->
Expect.equal expectedAst
{ types = actualAst.types
, words = actualAst.words
}
expectModuleOutput : Parser.AST -> FullyLoadedAST -> Expectation
expectModuleOutput parserAst expectedAst =
let
result =
AST.run
{ packageName = "play/test"
, modulePath = "some/module"
, ast = parserAst
................................................................................
}
in
case result of
Err errors ->
Expect.fail <| "Did not expect qualification to fail. Errors: " ++ Debug.toString errors
Ok actualAst ->
Expect.equal expectedAst
{ types = actualAst.types
, words = actualAst.words
}
expectModuleRequirements : Parser.AST -> List String -> List String -> List String -> Expectation
expectModuleRequirements parserAst expectedModulesToLoad expectedTypesToCheck expectedWordsToCheck =
let
result =
AST.run
{ packageName = ""
, modulePath = ""
, ast = parserAst
}
in
case result of
Err errors ->
Expect.fail <| "Did not expect qualification to fail. Errors: " ++ Debug.toString errors
Ok actualAst ->
Expect.equal
{ additionalModulesRequired = Set.fromList expectedModulesToLoad
, checkForExistingTypes = Set.fromList expectedTypesToCheck
, checkForExistingWords = Set.fromList expectedWordsToCheck
}
{ additionalModulesRequired = actualAst.additionalModulesRequired
, checkForExistingTypes = actualAst.checkForExistingTypes
, checkForExistingWords = actualAst.checkForExistingWords
}
addFunctionsForStructs : FullyLoadedAST -> FullyLoadedAST
addFunctionsForStructs ast =
let
helper _ t wipAst =
case t of
AST.CustomTypeDef name _ generics members ->
addFunctionsForStructsHelper name generics members wipAst
_ ->
wipAst
in
Dict.foldl helper ast ast.types
addFunctionsForStructsHelper : String -> List String -> List ( String, Type ) -> FullyLoadedAST -> FullyLoadedAST
addFunctionsForStructsHelper name generics members ast =
let
selfType =
if List.isEmpty generics then
Type.Custom name
else
|
Modified tests/Test/TypeChecker/Error.elm from [6a887ebaba] to [59a5248785].
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 |
False
in
checkForError inexhaustiveError input
]
]
checkForError : (Problem.Problem -> Bool) -> AST -> Expectation
checkForError fn source =
case TypeChecker.run source of
Err errors ->
if List.any fn errors then
Expect.pass
else
Expect.fail <| "Failed for unexpected reason: " ++ Debug.toString errors
Ok _ ->
Expect.fail "Did not expect type checking to succeed"
|
| |
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 |
False
in
checkForError inexhaustiveError input
]
]
checkForError : (Problem.Problem -> Bool) -> TypeChecker.LoadedQualifierAST a -> Expectation
checkForError fn source =
case TypeChecker.run source of
Err errors ->
if List.any fn errors then
Expect.pass
else
Expect.fail <| "Failed for unexpected reason: " ++ Debug.toString errors
Ok _ ->
Expect.fail "Did not expect type checking to succeed"
|