wip

src/Compiler/TypeInference.elm

@@ -929,6 +929,8 @@ bindTypeVariableTo inferredType ( replacedName, replacedType ) =
         return inferredType
 
 
+{-| TODO rename to something else?
+-}
 typeVarsFromType : Type -> Set Name
 typeVarsFromType ty =
     case ty of

src/Compiler/TypeInference_Test.elm

@@ -93,12 +93,19 @@ typeRecord { extensible, attrs } =
 --
 
 
+testDefs : Dict String Type
+testDefs =
+    Dict.empty
+        |> Dict.insert "Test.add" (function tyNumber (function tyNumber tyNumber))
+        |> Dict.insert "Test.reset" (typeFunction { from = tyNumber, fromIsMutable = True, to = tyNone })
+
+
 infer : String -> String -> Result String { forall : Set String, type_ : Type, mutable : Bool }
 infer name code =
     code
         |> TH.stringToCanonicalModuleWithPos
         |> Result.map (Dict.union Prelude.prelude >> TI.allDefsToEnvAndValues)
-        |> Result.andThen (\( env, values ) -> TI.fromAllValueDefs env values)
+        |> Result.andThen (\( env, values ) -> TI.fromAllValueDefs (addTestDefs env) values)
         |> TH.resErrorToString code
         |> Result.andThen
             (\env ->
@@ -116,22 +123,22 @@ infer name code =
             )
 
 
+addTestDefs : TI.Env -> TI.Env
+addTestDefs env =
+    let
+        add : String -> Type -> Dict String TI.InstanceVariable -> Dict String TI.InstanceVariable
+        add name ty =
+            Dict.insert name
+                { definedAt = CA.posDummy
+                , ty = ty
+                , freeTypeVariables = TI.typeVarsFromType ty
+                , isMutable = False
+                }
+    in
+    { env | instanceVariables = Dict.foldl add env.instanceVariables testDefs }
+
+
 
-{- TODO restore
-   preamble : Dict String TI.
-   preamble =
-       let
-           em x =
-               { type_ = x
-               , forall = Set.empty
-               , mutable = False
-               }
-       in
-       [ ( "Test.add", em <| function tyNumber (function tyNumber tyNumber) )
-       , ( "Test.reset", em <| typeFunction { from = tyNumber, fromIsMutable = True, to = tyNone } )
-       ]
-           |> Dict.fromList
--}
 ----
 --- "t2" -> "a"
 --

src/Types/CanonicalAst.elm

@@ -16,7 +16,23 @@ type alias AllDefs =
     Dict String RootDef
 
 
-{-| moduleName + start + end must be unique for every expression, because they are used to build a unique id
+{-|
+
+  TODO replace with
+
+  type Pos =
+      R -- replaced for pretty printing
+      N -- native
+      T -- defined as test
+      I -- defined by inference module
+      P String Int Int -- actual position
+
+  This way:
+    * I can remove all dummies
+    * I can track where stuff was defined
+    * takes less space when logging
+    * Error messages can account for it and print meaningful and readable information
+
 -}
 type alias Pos =
     { n : String