Stabel

Check-in [cde5af7586]
Login
Overview
Comment:Rename Play namespace to Stabel.
Timelines: family | ancestors | descendants | both | rebranding
Files: files | file ages | folders
SHA3-256: cde5af758667008ed1fa07332c86b687c90f0e1da2dcc3b59e3a2d8a39ad24b6
User & Date: robin.hansen on 2021-06-03 09:27:27
Other Links: branch diff | manifest | tags
Context
2021-06-03
09:33
Change string literals that contains 'play' to reference 'stabel' instead. Closed-Leaf check-in: 4fffdf1ce2 user: robin.hansen tags: rebranding
09:27
Rename Play namespace to Stabel. check-in: cde5af7586 user: robin.hansen tags: rebranding
09:00
Updated PackageLoader with new filename extension and name of .json metadata file. check-in: 39d1781e1d user: robin.hansen tags: rebranding
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Modified src/CLI.elm from [c955eddac9] to [c0ba24cd83].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
port module CLI exposing (main)

import Json.Decode as Json
import Json.Encode as Encode
import Platform exposing (Program)
import Play.Codegen as Codegen
import Play.Data.PackagePath as PackagePath
import Play.PackageLoader as PackageLoader
import Play.TypeChecker as TypeChecker
import Play.TypeChecker.Problem as TypeCheckerProblem
import Wasm


type alias Flags =
    { projectDir : String
    , entryPoint : Maybe String
    , stdLibPath : String





|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
port module CLI exposing (main)

import Json.Decode as Json
import Json.Encode as Encode
import Platform exposing (Program)
import Stabel.Codegen as Codegen
import Stabel.Data.PackagePath as PackagePath
import Stabel.PackageLoader as PackageLoader
import Stabel.TypeChecker as TypeChecker
import Stabel.TypeChecker.Problem as TypeCheckerProblem
import Wasm


type alias Flags =
    { projectDir : String
    , entryPoint : Maybe String
    , stdLibPath : String

Modified src/Stabel/Codegen.elm from [785ddad7e6] to [f0e0af3247].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Play.Codegen exposing (..)

import Dict exposing (Dict)
import List.Extra as List
import Play.Codegen.BaseModule as BaseModule
import Play.Data.Builtin as Builtin exposing (Builtin)
import Play.Data.Type as Type exposing (Type, WordType)
import Play.TypeChecker as AST exposing (AST)
import Wasm


type alias TypeInformation =
    { id : Int
    , members : List ( String, Type )
    }
|



|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Stabel.Codegen exposing (..)

import Dict exposing (Dict)
import List.Extra as List
import Stabel.Codegen.BaseModule as BaseModule
import Stabel.Data.Builtin as Builtin exposing (Builtin)
import Stabel.Data.Type as Type exposing (Type, WordType)
import Stabel.TypeChecker as AST exposing (AST)
import Wasm


type alias TypeInformation =
    { id : Int
    , members : List ( String, Type )
    }

Modified src/Stabel/Codegen/BaseModule.elm from [20f472e2d6] to [00776dc6c5].

1
2
3
4
5
6
7
8
module Play.Codegen.BaseModule exposing (..)

import Wasm



-- Constants

|







1
2
3
4
5
6
7
8
module Stabel.Codegen.BaseModule exposing (..)

import Wasm



-- Constants

Modified src/Stabel/Data/Builtin.elm from [0bf08e2fda] to [f4b853399b].

1
2
3
4
5
6
7
8
9
10
module Play.Data.Builtin exposing (..)

import Play.Data.Type as Type exposing (WordType)


type Builtin
    = Plus
    | Minus
    | Multiply
    | Divide
|

|







1
2
3
4
5
6
7
8
9
10
module Stabel.Data.Builtin exposing (..)

import Stabel.Data.Type as Type exposing (WordType)


type Builtin
    = Plus
    | Minus
    | Multiply
    | Divide

Modified src/Stabel/Data/Metadata.elm from [4a5e9363a6] to [510597f370].

1
2
3
4
5
6
7
8
9
10
11
12
13
module Play.Data.Metadata exposing (..)

import Dict exposing (Dict)
import Play.Data.SourceLocation exposing (SourceLocationRange)
import Play.Data.Type exposing (Type)
import Play.Data.TypeSignature exposing (TypeSignature(..))


type alias Metadata =
    { isEntryPoint : Bool
    , type_ : TypeSignature
    , isQuoted : Bool
    , sourceLocationRange : Maybe SourceLocationRange
|


|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
module Stabel.Data.Metadata exposing (..)

import Dict exposing (Dict)
import Stabel.Data.SourceLocation exposing (SourceLocationRange)
import Stabel.Data.Type exposing (Type)
import Stabel.Data.TypeSignature exposing (TypeSignature(..))


type alias Metadata =
    { isEntryPoint : Bool
    , type_ : TypeSignature
    , isQuoted : Bool
    , sourceLocationRange : Maybe SourceLocationRange

Modified src/Stabel/Data/ModuleName.elm from [1e115d5ae1] to [7acfd2f72d].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Play.Data.ModuleName exposing
    ( ModuleName
    , fromString
    , toPartStrings
    , toString
    )

import Play.Data.PackageName as PackageName


type ModuleName
    = ModuleName String


fromString : String -> Result () ModuleName
|






|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Stabel.Data.ModuleName exposing
    ( ModuleName
    , fromString
    , toPartStrings
    , toString
    )

import Stabel.Data.PackageName as PackageName


type ModuleName
    = ModuleName String


fromString : String -> Result () ModuleName

Modified src/Stabel/Data/PackageMetadata.elm from [cab47e39e5] to [f79d36c524].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Play.Data.PackageMetadata exposing
    ( PackageMetadata
    , decoder
    )

import Dict exposing (Dict)
import Json.Decode as Json
import Play.Data.ModuleName as ModuleName exposing (ModuleName)
import Play.Data.PackageName as PackageName exposing (PackageName)
import Play.Data.PackagePath as PackagePath exposing (PackagePath)
import Play.Data.SemanticVersion as SemanticVersion exposing (SemanticVersion)


type alias PackageMetadata =
    { name : PackageName
    , version : SemanticVersion
    , compatibleLanguageVersion : SemanticVersion
    , exposedModules : List ModuleName
|






|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Stabel.Data.PackageMetadata exposing
    ( PackageMetadata
    , decoder
    )

import Dict exposing (Dict)
import Json.Decode as Json
import Stabel.Data.ModuleName as ModuleName exposing (ModuleName)
import Stabel.Data.PackageName as PackageName exposing (PackageName)
import Stabel.Data.PackagePath as PackagePath exposing (PackagePath)
import Stabel.Data.SemanticVersion as SemanticVersion exposing (SemanticVersion)


type alias PackageMetadata =
    { name : PackageName
    , version : SemanticVersion
    , compatibleLanguageVersion : SemanticVersion
    , exposedModules : List ModuleName

Modified src/Stabel/Data/PackageName.elm from [83dc1a13a9] to [4c8f109469].

1
2
3
4
5
6
7
8
module Play.Data.PackageName exposing
    ( PackageName
    , fromString
    , invalidPart
    , toString
    )


|







1
2
3
4
5
6
7
8
module Stabel.Data.PackageName exposing
    ( PackageName
    , fromString
    , invalidPart
    , toString
    )


Modified src/Stabel/Data/PackagePath.elm from [1e9585ddbd] to [a00d165d99].

1
2
3
4
5
6
7
8
module Play.Data.PackagePath exposing
    ( PackagePath(..)
    , fromString
    , prefix
    )


type PackagePath
|







1
2
3
4
5
6
7
8
module Stabel.Data.PackagePath exposing
    ( PackagePath(..)
    , fromString
    , prefix
    )


type PackagePath

Modified src/Stabel/Data/SemanticVersion.elm from [b8b4cd3223] to [83ff2799b0].

1
2
3
4
5
6
7
8
module Play.Data.SemanticVersion exposing
    ( Compatibility(..)
    , ParseError(..)
    , SemanticVersion
    , compatible
    , fromString
    )

|







1
2
3
4
5
6
7
8
module Stabel.Data.SemanticVersion exposing
    ( Compatibility(..)
    , ParseError(..)
    , SemanticVersion
    , compatible
    , fromString
    )

Modified src/Stabel/Data/SourceLocation.elm from [40ebfca2d9] to [6c04d804ba].

1
2
3
4
5
6
7
8
module Play.Data.SourceLocation exposing (..)


type alias SourceLocationRange =
    { start : SourceLocation
    , end : SourceLocation
    }

|







1
2
3
4
5
6
7
8
module Stabel.Data.SourceLocation exposing (..)


type alias SourceLocationRange =
    { start : SourceLocation
    , end : SourceLocation
    }

Modified src/Stabel/Data/Type.elm from [7660e71094] to [54096b4f0c].

1
2
3
4
5
6
7
8
module Play.Data.Type exposing
    ( Type(..)
    , WordType
    , compatibleWords
    , emptyWordType
    , genericName
    , genericlyCompatible
    , isGeneric
|







1
2
3
4
5
6
7
8
module Stabel.Data.Type exposing
    ( Type(..)
    , WordType
    , compatibleWords
    , emptyWordType
    , genericName
    , genericlyCompatible
    , isGeneric

Modified src/Stabel/Data/TypeSignature.elm from [7ee4340b00] to [87ce6f3109].

1
2
3
4
5
6
7
8
9
10
module Play.Data.TypeSignature exposing (..)

import Play.Data.Type exposing (WordType)


type TypeSignature
    = NotProvided
    | UserProvided WordType
    | CompilerProvided WordType

|

|







1
2
3
4
5
6
7
8
9
10
module Stabel.Data.TypeSignature exposing (..)

import Stabel.Data.Type exposing (WordType)


type TypeSignature
    = NotProvided
    | UserProvided WordType
    | CompilerProvided WordType

Modified src/Stabel/PackageLoader.elm from [65bafe5f2d] to [5e78c07643].

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
module Play.PackageLoader exposing
    ( Model(..)
    , Msg(..)
    , Problem(..)
    , SideEffect(..)
    , getSideEffect
    , init
    , problemToString
    , update
    )

import Dict exposing (Dict)
import Json.Decode as Json
import List.Extra as List


import Play.Data.Metadata as Metadata
import Play.Data.ModuleName as ModuleName exposing (ModuleName)
import Play.Data.PackageMetadata as PackageMetadata exposing (PackageMetadata)
import Play.Data.PackageName as PackageName exposing (PackageName)
import Play.Data.PackagePath as PackagePath exposing (PackagePath)
import Play.Data.SemanticVersion as SemanticVersion exposing (SemanticVersion)
import Play.Parser as Parser
import Play.Parser.Problem as ParserProblem
import Play.Qualifier as Qualifier
import Play.Qualifier.Problem as QualifierProblem
import Result.Extra as Result
import Set exposing (Set)


type Problem
    = InvalidPackageMetadata String String
    | UnknownMessageForState String
    | NoExposedModulesInRootProject
    | ModuleNotFound String
|













>
>
|
|
|
|
|
|
|
|
|
|
<
<







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
module Stabel.PackageLoader exposing
    ( Model(..)
    , Msg(..)
    , Problem(..)
    , SideEffect(..)
    , getSideEffect
    , init
    , problemToString
    , update
    )

import Dict exposing (Dict)
import Json.Decode as Json
import List.Extra as List
import Result.Extra as Result
import Set exposing (Set)
import Stabel.Data.Metadata as Metadata
import Stabel.Data.ModuleName as ModuleName exposing (ModuleName)
import Stabel.Data.PackageMetadata as PackageMetadata exposing (PackageMetadata)
import Stabel.Data.PackageName as PackageName exposing (PackageName)
import Stabel.Data.PackagePath as PackagePath exposing (PackagePath)
import Stabel.Data.SemanticVersion as SemanticVersion exposing (SemanticVersion)
import Stabel.Parser as Parser
import Stabel.Parser.Problem as ParserProblem
import Stabel.Qualifier as Qualifier
import Stabel.Qualifier.Problem as QualifierProblem




type Problem
    = InvalidPackageMetadata String String
    | UnknownMessageForState String
    | NoExposedModulesInRootProject
    | ModuleNotFound String

Modified src/Stabel/Parser.elm from [fcb864ece6] to [86504ca9cd].

1
2
3
4
5
6
7
8
..
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
module Play.Parser exposing
    ( AST
    , AstNode(..)
    , ModuleDefinition(..)
    , ModuleDefinitionRec
    , PossiblyQualifiedType(..)
    , TypeDefinition(..)
    , TypeMatch(..)
................................................................................
    , typeDefinitionName
    , typeSignatureToMaybe
    )

import Dict exposing (Dict)
import Dict.Extra as Dict
import Parser.Advanced as Parser exposing ((|.), (|=), Token(..))
import Play.Data.SourceLocation exposing (SourceLocation, SourceLocationRange)
import Play.Parser.Problem exposing (..)
import Set exposing (Set)


type alias Parser a =
    Parser.Parser () Problem a


type alias AST =
|







 







|
|
|







1
2
3
4
5
6
7
8
..
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
module Stabel.Parser exposing
    ( AST
    , AstNode(..)
    , ModuleDefinition(..)
    , ModuleDefinitionRec
    , PossiblyQualifiedType(..)
    , TypeDefinition(..)
    , TypeMatch(..)
................................................................................
    , typeDefinitionName
    , typeSignatureToMaybe
    )

import Dict exposing (Dict)
import Dict.Extra as Dict
import Parser.Advanced as Parser exposing ((|.), (|=), Token(..))
import Set exposing (Set)
import Stabel.Data.SourceLocation exposing (SourceLocation, SourceLocationRange)
import Stabel.Parser.Problem exposing (..)


type alias Parser a =
    Parser.Parser () Problem a


type alias AST =

Modified src/Stabel/Parser/Problem.elm from [7563961c4b] to [082d961418].

1
2
3
4
5
6
7
8
9
10
11
12
13
module Play.Parser.Problem exposing
    ( Problem(..)
    , toString
    )

import Play.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)


type Problem
    = NotInt
    | NotSymbol
    | NotMetadata
    | NotGeneric
|




|







1
2
3
4
5
6
7
8
9
10
11
12
13
module Stabel.Parser.Problem exposing
    ( Problem(..)
    , toString
    )

import Stabel.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)


type Problem
    = NotInt
    | NotSymbol
    | NotMetadata
    | NotGeneric

Modified src/Stabel/Qualifier.elm from [0a582ab702] to [0fe7082632].

1
2
3
4


5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module Play.Qualifier exposing (..)

import Dict exposing (Dict)
import List.Extra as List


import Play.Data.Builtin as Builtin exposing (Builtin)
import Play.Data.Metadata as Metadata exposing (Metadata)
import Play.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Play.Data.Type as Type exposing (Type, WordType)
import Play.Data.TypeSignature as TypeSignature
import Play.Parser as Parser
import Play.Qualifier.Problem exposing (Problem(..))
import Result.Extra as Result
import Set exposing (Set)


type alias AST =
    { types : Dict String TypeDefinition
    , words : Dict String WordDefinition
    }

|



>
>
|
|
|
|
|
|
|
<
<







1
2
3
4
5
6
7
8
9
10
11
12
13


14
15
16
17
18
19
20
module Stabel.Qualifier exposing (..)

import Dict exposing (Dict)
import List.Extra as List
import Result.Extra as Result
import Set exposing (Set)
import Stabel.Data.Builtin as Builtin exposing (Builtin)
import Stabel.Data.Metadata as Metadata exposing (Metadata)
import Stabel.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Stabel.Data.Type as Type exposing (Type, WordType)
import Stabel.Data.TypeSignature as TypeSignature
import Stabel.Parser as Parser
import Stabel.Qualifier.Problem exposing (Problem(..))




type alias AST =
    { types : Dict String TypeDefinition
    , words : Dict String WordDefinition
    }

Modified src/Stabel/Qualifier/Problem.elm from [cf36a1d3b1] to [76de36ead2].

1
2
3
4
5
6
7
8
9
10
11
12
13
module Play.Qualifier.Problem exposing
    ( Problem(..)
    , toString
    )

import Play.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)


type Problem
    = UnknownWordRef SourceLocationRange String
    | UnknownTypeRef SourceLocationRange String
    | UnionTypeMatchWithPatterns SourceLocationRange
    | InvalidTypeMatch SourceLocationRange
|




|







1
2
3
4
5
6
7
8
9
10
11
12
13
module Stabel.Qualifier.Problem exposing
    ( Problem(..)
    , toString
    )

import Stabel.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)


type Problem
    = UnknownWordRef SourceLocationRange String
    | UnknownTypeRef SourceLocationRange String
    | UnionTypeMatchWithPatterns SourceLocationRange
    | InvalidTypeMatch SourceLocationRange

Modified src/Stabel/TypeChecker.elm from [267b56b8c9] to [0164e41594].

1
2
3
4
5

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module Play.TypeChecker exposing (..)

import Dict exposing (Dict)
import Dict.Extra as Dict
import List.Extra as List

import Play.Data.Builtin as Builtin exposing (Builtin)
import Play.Data.Metadata exposing (Metadata)
import Play.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Play.Data.Type as Type exposing (Type, WordType)
import Play.Data.TypeSignature as TypeSignature exposing (TypeSignature)
import Play.Qualifier as Qualifier
import Play.TypeChecker.Problem exposing (Problem(..))
import Set exposing (Set)


type alias AST =
    { types : Dict String TypeDefinition
    , words : Dict String WordDefinition
    }

|




>
|
|
|
|
|
|
|
<







1
2
3
4
5
6
7
8
9
10
11
12
13

14
15
16
17
18
19
20
module Stabel.TypeChecker exposing (..)

import Dict exposing (Dict)
import Dict.Extra as Dict
import List.Extra as List
import Set exposing (Set)
import Stabel.Data.Builtin as Builtin exposing (Builtin)
import Stabel.Data.Metadata exposing (Metadata)
import Stabel.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Stabel.Data.Type as Type exposing (Type, WordType)
import Stabel.Data.TypeSignature as TypeSignature exposing (TypeSignature)
import Stabel.Qualifier as Qualifier
import Stabel.TypeChecker.Problem exposing (Problem(..))



type alias AST =
    { types : Dict String TypeDefinition
    , words : Dict String WordDefinition
    }

Modified src/Stabel/TypeChecker/Problem.elm from [63d1018a02] to [fdbd9948ec].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Play.TypeChecker.Problem exposing
    ( Problem(..)
    , toString
    )

import Play.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Play.Data.Type as Type exposing (Type, WordType)
import Set exposing (Set)


type Problem
    = UndeclaredGeneric SourceLocationRange String (Set String)
    | TypeError SourceLocationRange String WordType WordType
    | UnexpectedType SourceLocationRange String Type Type
    | InconsistentWhens SourceLocationRange String
|




|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
module Stabel.TypeChecker.Problem exposing
    ( Problem(..)
    , toString
    )

import Set exposing (Set)
import Stabel.Data.SourceLocation as SourceLocation exposing (SourceLocationRange)
import Stabel.Data.Type as Type exposing (Type, WordType)


type Problem
    = UndeclaredGeneric SourceLocationRange String (Set String)
    | TypeError SourceLocationRange String WordType WordType
    | UnexpectedType SourceLocationRange String Type Type
    | InconsistentWhens SourceLocationRange String

Modified src/TestCompiler.elm from [3223a451b4] to [85fae358af].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
port module TestCompiler exposing (main)

import Dict
import Platform exposing (Program)
import Play.Codegen as Codegen
import Play.Data.Metadata as Metadata
import Play.Parser as Parser
import Play.Parser.Problem as ParserProblem
import Play.Qualifier as Qualifier
import Play.Qualifier.Problem as QualifierProblem
import Play.TypeChecker as TypeChecker
import Play.TypeChecker.Problem as TypeCheckerProblem
import Wasm


type alias Model =
    ()






|
|
|
|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
port module TestCompiler exposing (main)

import Dict
import Platform exposing (Program)
import Stabel.Codegen as Codegen
import Stabel.Data.Metadata as Metadata
import Stabel.Parser as Parser
import Stabel.Parser.Problem as ParserProblem
import Stabel.Qualifier as Qualifier
import Stabel.Qualifier.Problem as QualifierProblem
import Stabel.TypeChecker as TypeChecker
import Stabel.TypeChecker.Problem as TypeCheckerProblem
import Wasm


type alias Model =
    ()


Modified tests/Test/Data/ModuleName.elm from [96d969b684] to [c91b0806b9].

1
2
3
4
5
6
7
8
9
10
11
12
13
module Test.Data.ModuleName exposing (suite)

import Expect
import Fuzz
import Play.Data.ModuleName as ModuleName
import Play.Data.PackageName as PackageName
import Test exposing (Test, describe, fuzz, test)


suite : Test
suite =
    describe "ModuleName"
        [ fuzz Fuzz.string "Valid 2-part module names are also valid package names" <|




|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
module Test.Data.ModuleName exposing (suite)

import Expect
import Fuzz
import Stabel.Data.ModuleName as ModuleName
import Stabel.Data.PackageName as PackageName
import Test exposing (Test, describe, fuzz, test)


suite : Test
suite =
    describe "ModuleName"
        [ fuzz Fuzz.string "Valid 2-part module names are also valid package names" <|

Modified tests/Test/Data/PackageName.elm from [bcb092c8ca] to [f605b6f096].

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
module Test.Data.PackageName exposing (suite)

import Expect
import Play.Data.PackageName as PackageName
import Test exposing (Test, describe, test)
import Test.PlayExpect as PlayExpect



suite : Test
suite =
    describe "PackageName"
        [ test "valid package names" <|
            \_ ->
                PlayExpect.allOk PackageName.fromString
                    [ "some/package"
                    , "play/std_lib"
                    , "number1/package123"
                    , "play_std/lib"
                    ]
        , test "Must contain exactly two parts, seperated by a single slash" <|
            \_ ->
                PlayExpect.allErr PackageName.fromString
                    [ "/"
                    , "one/"
                    , "/one"
                    , "one"
                    , "one/two/three"
                    ]
        , test "Both parts of a name must start with lower cased ascii character" <|
            \_ ->
                PlayExpect.allErr PackageName.fromString
                    [ "1pack/name"
                    , "_priv/pack"
                    , "#whaaat/events"
                    , "Some/package"
                    , "pack/1name"
                    , "priv/_pack"
                    , "whaaat/#events"
                    , "some/Package"
                    ]
        , test "Both parts of a name cannot contain upper case letters" <|
            \_ ->
                PlayExpect.allErr PackageName.fromString
                    [ "myPack/name"
                    , "mypackage/someName"
                    , "mypackage/some_Name"
                    ]
        , test "Both parts of a name cannot contain non ascii or digit letters" <|
            \_ ->
                PlayExpect.allErr PackageName.fromString
                    [ "my#pack/name"
                    , "mypackage/bills$"
                    ]
        ]


<
|

<
>







|

|

|



|








|











|






|




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
module Test.Data.PackageName exposing (suite)


import Stabel.Data.PackageName as PackageName
import Test exposing (Test, describe, test)

import Test.StabelExpect as StabelExpect


suite : Test
suite =
    describe "PackageName"
        [ test "valid package names" <|
            \_ ->
                StabelExpect.allOk PackageName.fromString
                    [ "some/package"
                    , "stabel/std_lib"
                    , "number1/package123"
                    , "stabel_std/lib"
                    ]
        , test "Must contain exactly two parts, seperated by a single slash" <|
            \_ ->
                StabelExpect.allErr PackageName.fromString
                    [ "/"
                    , "one/"
                    , "/one"
                    , "one"
                    , "one/two/three"
                    ]
        , test "Both parts of a name must start with lower cased ascii character" <|
            \_ ->
                StabelExpect.allErr PackageName.fromString
                    [ "1pack/name"
                    , "_priv/pack"
                    , "#whaaat/events"
                    , "Some/package"
                    , "pack/1name"
                    , "priv/_pack"
                    , "whaaat/#events"
                    , "some/Package"
                    ]
        , test "Both parts of a name cannot contain upper case letters" <|
            \_ ->
                StabelExpect.allErr PackageName.fromString
                    [ "myPack/name"
                    , "mypackage/someName"
                    , "mypackage/some_Name"
                    ]
        , test "Both parts of a name cannot contain non ascii or digit letters" <|
            \_ ->
                StabelExpect.allErr PackageName.fromString
                    [ "my#pack/name"
                    , "mypackage/bills$"
                    ]
        ]

Modified tests/Test/Data/PackagePath.elm from [156de36d36] to [4f8b1dae93].

1
2
3
4
5
6
7
8
9
10
11
module Test.Data.PackagePath exposing (suite)

import Expect
import Play.Data.PackagePath as PackagePath
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "PackagePath"
        [ test "Any path not ending in * is a directory" <|



|







1
2
3
4
5
6
7
8
9
10
11
module Test.Data.PackagePath exposing (suite)

import Expect
import Stabel.Data.PackagePath as PackagePath
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "PackagePath"
        [ test "Any path not ending in * is a directory" <|

Modified tests/Test/Data/SemanticVersion.elm from [831feac96b] to [8a6bda5641].

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
..
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
module Test.Data.SemanticVersion exposing (suite)

import Expect
import Play.Data.SemanticVersion as SemanticVersion
import Test exposing (Test, describe, test)
import Test.PlayExpect as PlayExpect


suite : Test
suite =
    describe "SemanticVersion"
        [ test "Valid versions" <|
            \_ ->
                PlayExpect.allOk SemanticVersion.fromString
                    [ "1.2.3"
                    , "10.100.1000"
                    , "0.0.1"
                    , "0.1.0"
                    ]
        , test "Cannot contain more than three parts" <|
            \_ ->
                SemanticVersion.fromString "1.2.3.4"
                    |> Expect.equal (Err <| SemanticVersion.InvalidFormat "1.2.3.4")
        , test "Cannot contain less than three parts" <|
            \_ ->
                PlayExpect.allEqual SemanticVersion.fromString
                    [ ( "1", Err <| SemanticVersion.InvalidFormat "1" )
                    , ( "1.2", Err <| SemanticVersion.InvalidFormat "1.2" )
                    ]
        , test "Cannot be empty string" <|
            \_ ->
                SemanticVersion.fromString ""
                    |> Expect.equal (Err <| SemanticVersion.InvalidFormat "")
        , test "Must be numbers" <|
            \_ ->
                PlayExpect.allEqual SemanticVersion.fromString
                    [ ( "A", Err <| SemanticVersion.InvalidFormat "A" )
                    , ( "*", Err <| SemanticVersion.InvalidFormat "*" )
                    , ( "~", Err <| SemanticVersion.InvalidFormat "~" )
                    , ( "1.0.x", Err <| SemanticVersion.ExpectedInteger "1.0.x" )
                    , ( "1.0.~", Err <| SemanticVersion.ExpectedInteger "1.0.~" )
                    , ( "~1.0.0", Err <| SemanticVersion.ExpectedInteger "~1.0.0" )
                    , ( "1.0.0-alpha1", Err <| SemanticVersion.ExpectedInteger "1.0.0-alpha1" )
................................................................................
                    ]
        , test "Minimum version is 0.0.1" <|
            \_ ->
                SemanticVersion.fromString "0.0.0"
                    |> Expect.equal (Err <| SemanticVersion.LessThanMinimumVersion "0.0.0")
        , test "Cannot contain negative versions" <|
            \_ ->
                PlayExpect.allEqual SemanticVersion.fromString
                    [ ( "-1.0.0", Err <| SemanticVersion.NegativeVersions "-1.0.0" )
                    , ( "1.-2.0", Err <| SemanticVersion.NegativeVersions "1.-2.0" )
                    , ( "1.2.-3", Err <| SemanticVersion.NegativeVersions "1.2.-3" )
                    ]
        , describe "Compatibility" <|
            let
                helper ( lhs, rhs ) =
                    Result.map2 SemanticVersion.compatible (SemanticVersion.fromString lhs) (SemanticVersion.fromString rhs)
            in
            [ test "Same version, or greater version, returns GreaterThanOrEqual" <|
                \_ ->
                    PlayExpect.allEqual helper
                        [ ( ( "1.0.0", "1.0.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "0.2.1", "0.2.1" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "2.0.8", "2.0.8" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "1.0.0", "1.2.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "2.1.0", "2.1.1" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "1.2.3", "1.3.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        ]
            , test "Lesser version returns LessThan" <|
                \_ ->
                    PlayExpect.allEqual helper
                        [ ( ( "0.2.1", "0.2.0" ), Ok SemanticVersion.LessThan )
                        , ( ( "1.1.0", "1.0.5" ), Ok SemanticVersion.LessThan )
                        , ( ( "2.1.3", "2.1.1" ), Ok SemanticVersion.LessThan )
                        , ( ( "1.2.3", "1.2.2" ), Ok SemanticVersion.LessThan )
                        ]
            , test "Incompatible versions" <|
                \_ ->
                    PlayExpect.allEqual helper
                        [ ( ( "0.2.1", "0.3.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "1.0.0", "2.0.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "1.2.0", "2.2.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "0.0.1", "1.0.1" ), Ok SemanticVersion.Incompatible )
                        ]
            ]
        ]



|

|







|











|









|







 







|











|









|







|







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
..
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
module Test.Data.SemanticVersion exposing (suite)

import Expect
import Stabel.Data.SemanticVersion as SemanticVersion
import Test exposing (Test, describe, test)
import Test.StabelExpect as StabelExpect


suite : Test
suite =
    describe "SemanticVersion"
        [ test "Valid versions" <|
            \_ ->
                StabelExpect.allOk SemanticVersion.fromString
                    [ "1.2.3"
                    , "10.100.1000"
                    , "0.0.1"
                    , "0.1.0"
                    ]
        , test "Cannot contain more than three parts" <|
            \_ ->
                SemanticVersion.fromString "1.2.3.4"
                    |> Expect.equal (Err <| SemanticVersion.InvalidFormat "1.2.3.4")
        , test "Cannot contain less than three parts" <|
            \_ ->
                StabelExpect.allEqual SemanticVersion.fromString
                    [ ( "1", Err <| SemanticVersion.InvalidFormat "1" )
                    , ( "1.2", Err <| SemanticVersion.InvalidFormat "1.2" )
                    ]
        , test "Cannot be empty string" <|
            \_ ->
                SemanticVersion.fromString ""
                    |> Expect.equal (Err <| SemanticVersion.InvalidFormat "")
        , test "Must be numbers" <|
            \_ ->
                StabelExpect.allEqual SemanticVersion.fromString
                    [ ( "A", Err <| SemanticVersion.InvalidFormat "A" )
                    , ( "*", Err <| SemanticVersion.InvalidFormat "*" )
                    , ( "~", Err <| SemanticVersion.InvalidFormat "~" )
                    , ( "1.0.x", Err <| SemanticVersion.ExpectedInteger "1.0.x" )
                    , ( "1.0.~", Err <| SemanticVersion.ExpectedInteger "1.0.~" )
                    , ( "~1.0.0", Err <| SemanticVersion.ExpectedInteger "~1.0.0" )
                    , ( "1.0.0-alpha1", Err <| SemanticVersion.ExpectedInteger "1.0.0-alpha1" )
................................................................................
                    ]
        , test "Minimum version is 0.0.1" <|
            \_ ->
                SemanticVersion.fromString "0.0.0"
                    |> Expect.equal (Err <| SemanticVersion.LessThanMinimumVersion "0.0.0")
        , test "Cannot contain negative versions" <|
            \_ ->
                StabelExpect.allEqual SemanticVersion.fromString
                    [ ( "-1.0.0", Err <| SemanticVersion.NegativeVersions "-1.0.0" )
                    , ( "1.-2.0", Err <| SemanticVersion.NegativeVersions "1.-2.0" )
                    , ( "1.2.-3", Err <| SemanticVersion.NegativeVersions "1.2.-3" )
                    ]
        , describe "Compatibility" <|
            let
                helper ( lhs, rhs ) =
                    Result.map2 SemanticVersion.compatible (SemanticVersion.fromString lhs) (SemanticVersion.fromString rhs)
            in
            [ test "Same version, or greater version, returns GreaterThanOrEqual" <|
                \_ ->
                    StabelExpect.allEqual helper
                        [ ( ( "1.0.0", "1.0.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "0.2.1", "0.2.1" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "2.0.8", "2.0.8" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "1.0.0", "1.2.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "2.1.0", "2.1.1" ), Ok SemanticVersion.GreaterThanOrEqual )
                        , ( ( "1.2.3", "1.3.0" ), Ok SemanticVersion.GreaterThanOrEqual )
                        ]
            , test "Lesser version returns LessThan" <|
                \_ ->
                    StabelExpect.allEqual helper
                        [ ( ( "0.2.1", "0.2.0" ), Ok SemanticVersion.LessThan )
                        , ( ( "1.1.0", "1.0.5" ), Ok SemanticVersion.LessThan )
                        , ( ( "2.1.3", "2.1.1" ), Ok SemanticVersion.LessThan )
                        , ( ( "1.2.3", "1.2.2" ), Ok SemanticVersion.LessThan )
                        ]
            , test "Incompatible versions" <|
                \_ ->
                    StabelExpect.allEqual helper
                        [ ( ( "0.2.1", "0.3.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "1.0.0", "2.0.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "1.2.0", "2.2.0" ), Ok SemanticVersion.Incompatible )
                        , ( ( "0.0.1", "1.0.1" ), Ok SemanticVersion.Incompatible )
                        ]
            ]
        ]

Modified tests/Test/PackageLoader.elm from [6218a072fb] to [08472bdfab].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.PackageLoader exposing (suite)

import Dict exposing (Dict)
import Dict.Extra as Dict
import Expect exposing (Expectation)
import List.Extra as List
import Play.Data.Builtin as Builtin
import Play.Data.Metadata as Metadata
import Play.Data.PackagePath as PackagePath
import Play.Data.SourceLocation exposing (emptyRange)
import Play.PackageLoader as PackageLoader
import Play.Qualifier as Qualifier
import Test exposing (Test, describe, test)
import Test.Qualifier.Util as Util


suite : Test
suite =
    let






|
|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.PackageLoader exposing (suite)

import Dict exposing (Dict)
import Dict.Extra as Dict
import Expect exposing (Expectation)
import List.Extra as List
import Stabel.Data.Builtin as Builtin
import Stabel.Data.Metadata as Metadata
import Stabel.Data.PackagePath as PackagePath
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.PackageLoader as PackageLoader
import Stabel.Qualifier as Qualifier
import Test exposing (Test, describe, test)
import Test.Qualifier.Util as Util


suite : Test
suite =
    let

Modified tests/Test/Parser.elm from [e119fc8848] to [6e738c2708].

1
2
3
4
5

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module Test.Parser exposing (..)

import Dict
import Dict.Extra as Dict
import Expect

import Play.Data.SourceLocation
    exposing
        ( SourceLocation
        , SourceLocationRange
        , emptyRange
        )
import Play.Parser as AST exposing (..)
import Set
import Test exposing (Test, describe, test)
import Test.Parser.Util
    exposing
        ( addFunctionsForStructs
        , compile
        , compileRetainLocations
        , expectCompiles





>
|





|
<







1
2
3
4
5
6
7
8
9
10
11
12
13

14
15
16
17
18
19
20
module Test.Parser exposing (..)

import Dict
import Dict.Extra as Dict
import Expect
import Set
import Stabel.Data.SourceLocation
    exposing
        ( SourceLocation
        , SourceLocationRange
        , emptyRange
        )
import Stabel.Parser as AST exposing (..)

import Test exposing (Test, describe, test)
import Test.Parser.Util
    exposing
        ( addFunctionsForStructs
        , compile
        , compileRetainLocations
        , expectCompiles

Modified tests/Test/Parser/Error.elm from [297a7bb4eb] to [aa4f3e7ab5].

1
2
3
4
5
6
7
8
9
10
11
12
module Test.Parser.Error exposing (..)

import Expect exposing (Expectation)
import Play.Parser exposing (..)
import Play.Parser.Problem exposing (Problem(..))
import Test exposing (Test, describe, test)
import Test.Parser.Util exposing (compile)


suite : Test
suite =
    describe "Parser errors"



|
|







1
2
3
4
5
6
7
8
9
10
11
12
module Test.Parser.Error exposing (..)

import Expect exposing (Expectation)
import Stabel.Parser exposing (..)
import Stabel.Parser.Problem exposing (Problem(..))
import Test exposing (Test, describe, test)
import Test.Parser.Util exposing (compile)


suite : Test
suite =
    describe "Parser errors"

Modified tests/Test/Parser/Util.elm from [c6efc18281] to [69907d4d01].

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    , compileRetainLocations
    , expectCompiles
    )

import Dict
import Dict.Extra as Dict
import Expect
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type exposing (Type)
import Play.Parser as AST exposing (..)
import Play.Parser.Problem exposing (Problem)
import String.Extra as String


compile : String -> Result (List Problem) AST
compile str =
    compileRetainLocations str
        |> Result.map stripLocations







|
|
|
|
|







4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    , compileRetainLocations
    , expectCompiles
    )

import Dict
import Dict.Extra as Dict
import Expect
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type exposing (Type)
import Stabel.Parser as AST exposing (..)
import Stabel.Parser.Problem exposing (Problem)
import String.Extra as String


compile : String -> Result (List Problem) AST
compile str =
    compileRetainLocations str
        |> Result.map stripLocations

Modified tests/Test/Qualifier.elm from [a69b471d1a] to [0ec62e07f6].

1
2
3
4
5

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
module Test.Qualifier exposing (..)

import Dict
import Dict.Extra as Dict
import Expect

import Play.Data.Builtin as Builtin
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type
import Play.Parser as AST
import Play.Qualifier exposing (..)
import Play.Qualifier.Problem as Problem
import Set
import Test exposing (Test, describe, test)
import Test.Parser.Util as ParserUtil
import Test.Qualifier.Util as QualifierUtil


suite : Test
suite =





>
|
|
|
|
|
|
|
<







1
2
3
4
5
6
7
8
9
10
11
12
13

14
15
16
17
18
19
20
module Test.Qualifier exposing (..)

import Dict
import Dict.Extra as Dict
import Expect
import Set
import Stabel.Data.Builtin as Builtin
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type
import Stabel.Parser as AST
import Stabel.Qualifier exposing (..)
import Stabel.Qualifier.Problem as Problem

import Test exposing (Test, describe, test)
import Test.Parser.Util as ParserUtil
import Test.Qualifier.Util as QualifierUtil


suite : Test
suite =

Modified tests/Test/Qualifier/Error.elm from [0f9091b125] to [afea07fa69].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Test.Qualifier.Error exposing (..)

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type
import Play.Parser as AST
import Play.Qualifier exposing (..)
import Play.Qualifier.Problem exposing (Problem(..))
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "Qualifier errors"
        [ describe "No such reference" <|





|
|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
module Test.Qualifier.Error exposing (..)

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type
import Stabel.Parser as AST
import Stabel.Qualifier exposing (..)
import Stabel.Qualifier.Problem exposing (Problem(..))
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "Qualifier errors"
        [ describe "No such reference" <|

Modified tests/Test/Qualifier/Util.elm from [d1d2da2384] to [e7236bb243].

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    , expectOutput
    , stripLocations
    )

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type exposing (Type)
import Play.Parser as Parser
import Play.Qualifier as AST
    exposing
        ( AST
        , Node(..)
        , TypeDefinition
        , TypeMatch(..)
        , TypeMatchValue(..)
        , WordDefinition







|
|
|
|
|







5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    , expectOutput
    , stripLocations
    )

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type exposing (Type)
import Stabel.Parser as Parser
import Stabel.Qualifier as AST
    exposing
        ( AST
        , Node(..)
        , TypeDefinition
        , TypeMatch(..)
        , TypeMatchValue(..)
        , WordDefinition

Modified tests/Test/StabelExpect.elm from [1b415049a2] to [f6a5e13a96].

1
2
3
4
5
6
7
8
module Test.PlayExpect exposing
    ( allEqual
    , allErr
    , allOk
    )

import Expect

|







1
2
3
4
5
6
7
8
module Test.StabelExpect exposing
    ( allEqual
    , allErr
    , allOk
    )

import Expect

Modified tests/Test/TypeChecker.elm from [5cf7f1ff07] to [09b3804701].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.TypeChecker exposing (..)

import Dict
import Dict.Extra as Dict
import Expect
import Play.Data.Builtin as Builtin
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type
import Play.Qualifier as QAST
import Play.TypeChecker exposing (..)
import Play.TypeChecker.Problem as Problem
import Test exposing (Test, describe, test)
import Test.Qualifier.Util as QualifierUtil


suite : Test
suite =
    describe "TypeChecker"





|
|
|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.TypeChecker exposing (..)

import Dict
import Dict.Extra as Dict
import Expect
import Stabel.Data.Builtin as Builtin
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type
import Stabel.Qualifier as QAST
import Stabel.TypeChecker exposing (..)
import Stabel.TypeChecker.Problem as Problem
import Test exposing (Test, describe, test)
import Test.Qualifier.Util as QualifierUtil


suite : Test
suite =
    describe "TypeChecker"

Modified tests/Test/TypeChecker/Error.elm from [8ad155b434] to [26f4b80df6].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.TypeChecker.Error exposing (..)

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Play.Data.Builtin as Builtin
import Play.Data.Metadata as Metadata
import Play.Data.SourceLocation exposing (emptyRange)
import Play.Data.Type as Type
import Play.Qualifier exposing (..)
import Play.TypeChecker as TypeChecker
import Play.TypeChecker.Problem as Problem
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "TypeChecker errors"
        [ test "Undeclared generic" <|





|
|
|
|
|
|
|







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Test.TypeChecker.Error exposing (..)

import Dict
import Dict.Extra as Dict
import Expect exposing (Expectation)
import Stabel.Data.Builtin as Builtin
import Stabel.Data.Metadata as Metadata
import Stabel.Data.SourceLocation exposing (emptyRange)
import Stabel.Data.Type as Type
import Stabel.Qualifier exposing (..)
import Stabel.TypeChecker as TypeChecker
import Stabel.TypeChecker.Problem as Problem
import Test exposing (Test, describe, test)


suite : Test
suite =
    describe "TypeChecker errors"
        [ test "Undeclared generic" <|