git.iko.soy/elk
on master help sign in
Switch Generate/JavaScript/ over to Data.Name
0d4ba6eEvan Czaplicki
compiler/src/Generate/JavaScript.hs+43−43
compare with master
unifiedsplit
@@ -13,6 +13,7 @@ import Data.Monoid ((<>))
13import qualified Data.List as List
13import qualified Data.List as List
14import Data.Map ((!))
14import Data.Map ((!))
15import qualified Data.Map as Map
15import qualified Data.Map as Map
16+import qualified Data.Name as Name
16import qualified Data.Set as Set
17import qualified Data.Set as Set
17import qualified Data.Text as Text
18import qualified Data.Text as Text
18import qualified Data.Text.Encoding as Text
19import qualified Data.Text.Encoding as Text
@@ -22,10 +23,9 @@ import qualified AST.Optimized as Opt
22import qualified AST.Module.Name as ModuleName
23import qualified AST.Module.Name as ModuleName
23import qualified Data.Index as Index
24import qualified Data.Index as Index
24import qualified Elm.Interface as I
25import qualified Elm.Interface as I
25−import qualified Elm.Name as N
26import qualified Generate.JavaScript.Builder as JS
26import qualified Generate.JavaScript.Builder as JS
27import qualified Generate.JavaScript.Expression as Expr
27import qualified Generate.JavaScript.Expression as Expr
28−import qualified Generate.JavaScript.Name as Name
28+import qualified Generate.JavaScript.Name as JsName
29import qualified Generate.JavaScript.Mode as Mode
29import qualified Generate.JavaScript.Mode as Mode
30import qualified Reporting.Doc as D
30import qualified Reporting.Doc as D
31import qualified Reporting.Render.Type as RT
31import qualified Reporting.Render.Type as RT
@@ -38,7 +38,7 @@ import qualified Reporting.Render.Type.Localizer as L
38
38
39data Output
39data Output
40 = None
40 = None
41− | Some N.Name [N.Name] B.Builder
41+ | Some Name.Name [Name.Name] B.Builder
42
42
43
43
44generate :: Mode.Mode -> Opt.Graph -> [ModuleName.Canonical] -> Output
44generate :: Mode.Mode -> Opt.Graph -> [ModuleName.Canonical] -> Output
@@ -85,7 +85,7 @@ perfNote mode =
85-- GENERATE FOR REPL
85-- GENERATE FOR REPL
86
86
87
87
88−generateForRepl :: Bool -> L.Localizer -> Opt.Graph -> I.Interface -> ModuleName.Canonical -> N.Name -> B.Builder
88+generateForRepl :: Bool -> L.Localizer -> Opt.Graph -> I.Interface -> ModuleName.Canonical -> Name.Name -> B.Builder
89generateForRepl ansi localizer (Opt.Graph _ graph _) iface home name =
89generateForRepl ansi localizer (Opt.Graph _ graph _) iface home name =
90 let
90 let
91 mode = Mode.dev Mode.Client
91 mode = Mode.dev Mode.Client
@@ -97,11 +97,11 @@ generateForRepl ansi localizer (Opt.Graph _ graph _) iface home name =
97 print ansi localizer home name (I._types iface ! name)
97 print ansi localizer home name (I._types iface ! name)
98
98
99
99
100−print :: Bool -> L.Localizer -> ModuleName.Canonical -> N.Name -> Can.Annotation -> B.Builder
100+print :: Bool -> L.Localizer -> ModuleName.Canonical -> Name.Name -> Can.Annotation -> B.Builder
101print ansi localizer home name (Can.Forall _ tipe) =
101print ansi localizer home name (Can.Forall _ tipe) =
102 let
102 let
103− value = Name.toBuilder (Name.fromGlobal home name)
103+ value = JsName.toBuilder (JsName.fromGlobal home name)
104− toString = Name.toBuilder (Name.fromKernel N.debug "toAnsiString")
104+ toString = JsName.toBuilder (JsName.fromKernel Name.debug "toAnsiString")
105 tipeDoc = RT.canToDoc localizer RT.None tipe
105 tipeDoc = RT.canToDoc localizer RT.None tipe
106 bool = if ansi then "true" else "false"
106 bool = if ansi then "true" else "false"
107 in
107 in
@@ -241,19 +241,19 @@ addKernel (State revKernels revBuilders seen) kernel =
241
241
242var :: Opt.Global -> Expr.Code -> JS.Stmt
242var :: Opt.Global -> Expr.Code -> JS.Stmt
243var (Opt.Global home name) code =
243var (Opt.Global home name) code =
244− JS.Var [ (Name.fromGlobal home name, Just (Expr.codeToExpr code)) ]
244+ JS.Var [ (JsName.fromGlobal home name, Just (Expr.codeToExpr code)) ]
245
245
246
246
247isDebugger :: Opt.Global -> Bool
247isDebugger :: Opt.Global -> Bool
248isDebugger (Opt.Global (ModuleName.Canonical _ home) _) =
248isDebugger (Opt.Global (ModuleName.Canonical _ home) _) =
249− home == N.debugger
249+ home == Name.debugger
250
250
251
251
252
252
253-- GENERATE CYCLES
253-- GENERATE CYCLES
254
254
255
255
256−generateCycle :: Mode.Mode -> Opt.Global -> [N.Name] -> [(N.Name, Opt.Expr)] -> [Opt.Def] -> JS.Stmt
256+generateCycle :: Mode.Mode -> Opt.Global -> [Name.Name] -> [(Name.Name, Opt.Expr)] -> [Opt.Def] -> JS.Stmt
257generateCycle mode (Opt.Global home _) names values functions =
257generateCycle mode (Opt.Global home _) names values functions =
258 JS.Block
258 JS.Block
259 [ JS.Block $ map (generateCycleFunc mode home) functions
259 [ JS.Block $ map (generateCycleFunc mode home) functions
@@ -268,8 +268,8 @@ generateCycle mode (Opt.Global home _) names values functions =
268 JS.Block realBlock
268 JS.Block realBlock
269
269
270 Mode.Dev _ _ ->
270 Mode.Dev _ _ ->
271− JS.Try (JS.Block realBlock) Name.dollar $ JS.Throw $ JS.String $
271+ JS.Try (JS.Block realBlock) JsName.dollar $ JS.Throw $ JS.String $
272− "Some top-level definitions from `" <> N.toBuilder (ModuleName._module home) <> "` are causing infinite recursion:\\n"
272+ "Some top-level definitions from `" <> Name.toBuilder (ModuleName._module home) <> "` are causing infinite recursion:\\n"
273 <> drawCycle names
273 <> drawCycle names
274 <> "\\n\\nThese errors are very tricky, so read "
274 <> "\\n\\nThese errors are very tricky, so read "
275 <> B.stringUtf8 (D.makeNakedLink "halting-problem")
275 <> B.stringUtf8 (D.makeNakedLink "halting-problem")
@@ -281,23 +281,23 @@ generateCycleFunc :: Mode.Mode -> ModuleName.Canonical -> Opt.Def -> JS.Stmt
281generateCycleFunc mode home def =
281generateCycleFunc mode home def =
282 case def of
282 case def of
283 Opt.Def name expr ->
283 Opt.Def name expr ->
284− JS.Var [ (Name.fromGlobal home name, Just (Expr.codeToExpr (Expr.generate mode expr))) ]
284+ JS.Var [ (JsName.fromGlobal home name, Just (Expr.codeToExpr (Expr.generate mode expr))) ]
285
285
286 Opt.TailDef name args expr ->
286 Opt.TailDef name args expr ->
287− JS.Var [ (Name.fromGlobal home name, Just (Expr.codeToExpr (Expr.generateTailDef mode name args expr))) ]
287+ JS.Var [ (JsName.fromGlobal home name, Just (Expr.codeToExpr (Expr.generateTailDef mode name args expr))) ]
288
288
289
289
290−generateSafeCycle :: Mode.Mode -> ModuleName.Canonical -> (N.Name, Opt.Expr) -> JS.Stmt
290+generateSafeCycle :: Mode.Mode -> ModuleName.Canonical -> (Name.Name, Opt.Expr) -> JS.Stmt
291generateSafeCycle mode home (name, expr) =
291generateSafeCycle mode home (name, expr) =
292− JS.FunctionStmt (Name.fromCycle home name) [] $
292+ JS.FunctionStmt (JsName.fromCycle home name) [] $
293 Expr.codeToStmtList (Expr.generate mode expr)
293 Expr.codeToStmtList (Expr.generate mode expr)
294
294
295
295
296−generateRealCycle :: ModuleName.Canonical -> (N.Name, expr) -> JS.Stmt
296+generateRealCycle :: ModuleName.Canonical -> (Name.Name, expr) -> JS.Stmt
297generateRealCycle home (name, _) =
297generateRealCycle home (name, _) =
298 let
298 let
299− safeName = Name.fromCycle home name
299+ safeName = JsName.fromCycle home name
300− realName = Name.fromGlobal home name
300+ realName = JsName.fromGlobal home name
301 in
301 in
302 JS.Block
302 JS.Block
303 [ JS.Var [ ( realName, Just (JS.Call (JS.Ref safeName) []) ) ]
303 [ JS.Var [ ( realName, Just (JS.Call (JS.Ref safeName) []) ) ]
@@ -306,11 +306,11 @@ generateRealCycle home (name, _) =
306 ]
306 ]
307
307
308
308
309−drawCycle :: [N.Name] -> B.Builder
309+drawCycle :: [Name.Name] -> B.Builder
310drawCycle names =
310drawCycle names =
311 let
311 let
312 topLine = "\\n ┌─────┐"
312 topLine = "\\n ┌─────┐"
313− nameLine name = "\\n │ " <> N.toBuilder name
313+ nameLine name = "\\n │ " <> Name.toBuilder name
314 midLine = "\\n │ ↓"
314 midLine = "\\n │ ↓"
315 bottomLine = "\\n └─────┘"
315 bottomLine = "\\n └─────┘"
316 in
316 in
@@ -333,16 +333,16 @@ addChunk mode builder chunk =
333 B.byteString javascript <> builder
333 B.byteString javascript <> builder
334
334
335 Opt.ElmVar home name ->
335 Opt.ElmVar home name ->
336− Name.toBuilder (Name.fromGlobal home name) <> builder
336+ JsName.toBuilder (JsName.fromGlobal home name) <> builder
337
337
338 Opt.JsVar home name ->
338 Opt.JsVar home name ->
339− Name.toBuilder (Name.fromKernel home name) <> builder
339+ JsName.toBuilder (JsName.fromKernel home name) <> builder
340
340
341 Opt.ElmField name ->
341 Opt.ElmField name ->
342− Name.toBuilder (Expr.generateField mode name) <> builder
342+ JsName.toBuilder (Expr.generateField mode name) <> builder
343
343
344 Opt.JsField int ->
344 Opt.JsField int ->
345− Name.toBuilder (Name.fromInt int) <> builder
345+ JsName.toBuilder (JsName.fromInt int) <> builder
346
346
347 Opt.JsEnum int ->
347 Opt.JsEnum int ->
348 B.intDec int <> builder
348 B.intDec int <> builder
@@ -379,7 +379,7 @@ generateEnum mode global@(Opt.Global home name) index =
379 Mode.Prod _ _ ->
379 Mode.Prod _ _ ->
380 JS.Int (Index.toMachine index)
380 JS.Int (Index.toMachine index)
381 in
381 in
382− JS.Var [ (Name.fromGlobal home name, Just definition) ]
382+ JS.Var [ (JsName.fromGlobal home name, Just definition) ]
383
383
384
384
385
385
@@ -395,25 +395,25 @@ generateBox mode global@(Opt.Global home name) =
395 Expr.codeToExpr (Expr.generateCtor mode global Index.first 1)
395 Expr.codeToExpr (Expr.generateCtor mode global Index.first 1)
396
396
397 Mode.Prod _ _ ->
397 Mode.Prod _ _ ->
398− JS.Ref (Name.fromGlobal ModuleName.basics N.identity)
398+ JS.Ref (JsName.fromGlobal ModuleName.basics Name.identity)
399 in
399 in
400− JS.Var [ (Name.fromGlobal home name, Just definition) ]
400+ JS.Var [ (JsName.fromGlobal home name, Just definition) ]
401
401
402
402
403
403
404-- GENERATE PORTS
404-- GENERATE PORTS
405
405
406
406
407−generatePort :: Mode.Mode -> Opt.Global -> N.Name -> Opt.Expr -> JS.Stmt
407+generatePort :: Mode.Mode -> Opt.Global -> Name.Name -> Opt.Expr -> JS.Stmt
408generatePort mode (Opt.Global home name) makePort converter =
408generatePort mode (Opt.Global home name) makePort converter =
409 let
409 let
410 definition =
410 definition =
411− JS.Call (JS.Ref (Name.fromKernel N.platform makePort))
411+ JS.Call (JS.Ref (JsName.fromKernel Name.platform makePort))
412− [ JS.String (N.toBuilder name)
412+ [ JS.String (Name.toBuilder name)
413 , Expr.codeToExpr (Expr.generate mode converter)
413 , Expr.codeToExpr (Expr.generate mode converter)
414 ]
414 ]
415 in
415 in
416− JS.Var [ (Name.fromGlobal home name, Just definition) ]
416+ JS.Var [ (JsName.fromGlobal home name, Just definition) ]
417
417
418
418
419
419
@@ -425,40 +425,40 @@ generateManager mode graph (Opt.Global home@(ModuleName.Canonical _ moduleName)
425 let
425 let
426 managerLVar =
426 managerLVar =
427 JS.LBracket
427 JS.LBracket
428− (JS.Ref (Name.fromKernel N.platform "effectManagers"))
428+ (JS.Ref (JsName.fromKernel Name.platform "effectManagers"))
429− (JS.String (N.toBuilder moduleName))
429+ (JS.String (Name.toBuilder moduleName))
430
430
431 (deps, args, stmts) =
431 (deps, args, stmts) =
432 generateManagerHelp home effectsType
432 generateManagerHelp home effectsType
433
433
434 createManager =
434 createManager =
435 JS.ExprStmt $ JS.Assign managerLVar $
435 JS.ExprStmt $ JS.Assign managerLVar $
436− JS.Call (JS.Ref (Name.fromKernel N.platform "createManager")) args
436+ JS.Call (JS.Ref (JsName.fromKernel Name.platform "createManager")) args
437 in
437 in
438 addStmt (List.foldl' (addGlobal mode graph) state deps) $
438 addStmt (List.foldl' (addGlobal mode graph) state deps) $
439 JS.Block (createManager : stmts)
439 JS.Block (createManager : stmts)
440
440
441
441
442−generateLeaf :: ModuleName.Canonical -> N.Name -> JS.Stmt
442+generateLeaf :: ModuleName.Canonical -> Name.Name -> JS.Stmt
443generateLeaf home@(ModuleName.Canonical _ moduleName) name =
443generateLeaf home@(ModuleName.Canonical _ moduleName) name =
444 let
444 let
445 definition =
445 definition =
446− JS.Call leaf [ JS.String (N.toBuilder moduleName) ]
446+ JS.Call leaf [ JS.String (Name.toBuilder moduleName) ]
447 in
447 in
448− JS.Var [ (Name.fromGlobal home name, Just definition) ]
448+ JS.Var [ (JsName.fromGlobal home name, Just definition) ]
449
449
450
450
451{-# NOINLINE leaf #-}
451{-# NOINLINE leaf #-}
452leaf :: JS.Expr
452leaf :: JS.Expr
453leaf =
453leaf =
454− JS.Ref (Name.fromKernel N.platform "leaf")
454+ JS.Ref (JsName.fromKernel Name.platform "leaf")
455
455
456
456
457generateManagerHelp :: ModuleName.Canonical -> Opt.EffectsType -> ([Opt.Global], [JS.Expr], [JS.Stmt])
457generateManagerHelp :: ModuleName.Canonical -> Opt.EffectsType -> ([Opt.Global], [JS.Expr], [JS.Stmt])
458generateManagerHelp home effectsType =
458generateManagerHelp home effectsType =
459 let
459 let
460 dep name = Opt.Global home name
460 dep name = Opt.Global home name
461− ref name = JS.Ref (Name.fromGlobal home name)
461+ ref name = JS.Ref (JsName.fromGlobal home name)
462 in
462 in
463 case effectsType of
463 case effectsType of
464 Opt.Cmd ->
464 Opt.Cmd ->
@@ -489,10 +489,10 @@ generateManagerHelp home effectsType =
489toMainExports :: Mode.Mode -> Map.Map ModuleName.Canonical Opt.Main -> B.Builder
489toMainExports :: Mode.Mode -> Map.Map ModuleName.Canonical Opt.Main -> B.Builder
490toMainExports mode mains =
490toMainExports mode mains =
491 let
491 let
492− export = Name.fromKernel N.platform "export"
492+ export = JsName.fromKernel Name.platform "export"
493 exports = generateExports mode (Map.foldrWithKey addToTrie emptyTrie mains)
493 exports = generateExports mode (Map.foldrWithKey addToTrie emptyTrie mains)
494 in
494 in
495− Name.toBuilder export <> "(" <> exports <> ");"
495+ JsName.toBuilder export <> "(" <> exports <> ");"
496
496
497
497
498generateExports :: Mode.Mode -> Trie -> B.Builder
498generateExports :: Mode.Mode -> Trie -> B.Builder
@@ -542,7 +542,7 @@ emptyTrie =
542
542
543addToTrie :: ModuleName.Canonical -> Opt.Main -> Trie -> Trie
543addToTrie :: ModuleName.Canonical -> Opt.Main -> Trie -> Trie
544addToTrie home@(ModuleName.Canonical _ moduleName) main trie =
544addToTrie home@(ModuleName.Canonical _ moduleName) main trie =
545− merge trie $ segmentsToTrie home (Text.splitOn "." (N.toText moduleName)) main
545+ merge trie $ segmentsToTrie home (Text.splitOn "." (Name.toText moduleName)) main
546
546
547
547
548segmentsToTrie :: ModuleName.Canonical -> [Text.Text] -> Opt.Main -> Trie
548segmentsToTrie :: ModuleName.Canonical -> [Text.Text] -> Opt.Main -> Trie
compiler/src/Generate/JavaScript/Expression.hs+100−100
@@ -16,6 +16,7 @@ import qualified Data.IntMap as IntMap
16import qualified Data.List as List
16import qualified Data.List as List
17import Data.Map ((!))
17import Data.Map ((!))
18import qualified Data.Map as Map
18import qualified Data.Map as Map
19+import qualified Data.Name as Name
19import qualified Data.Set as Set
20import qualified Data.Set as Set
20import qualified Data.Text.Encoding as Text
21import qualified Data.Text.Encoding as Text
21import qualified Data.Utf8 as Utf8
22import qualified Data.Utf8 as Utf8
@@ -26,12 +27,11 @@ import qualified AST.Module.Name as ModuleName
26import qualified Data.Index as Index
27import qualified Data.Index as Index
27import qualified Elm.Compiler.Type as Type
28import qualified Elm.Compiler.Type as Type
28import qualified Elm.Compiler.Type.Extract as Extract
29import qualified Elm.Compiler.Type.Extract as Extract
29−import qualified Elm.Name as N
30import qualified Elm.Package as Pkg
30import qualified Elm.Package as Pkg
31import qualified Elm.Compiler.Version as Version
31import qualified Elm.Compiler.Version as Version
32import qualified Generate.JavaScript.Builder as JS
32import qualified Generate.JavaScript.Builder as JS
33import qualified Generate.JavaScript.Mode as Mode
33import qualified Generate.JavaScript.Mode as Mode
34−import qualified Generate.JavaScript.Name as Name
34+import qualified Generate.JavaScript.Name as JsName
35import qualified Json.Encode as Encode
35import qualified Json.Encode as Encode
36import qualified Optimize.DecisionTree as DT
36import qualified Optimize.DecisionTree as DT
37import qualified Reporting.Region as R
37import qualified Reporting.Region as R
@@ -71,15 +71,15 @@ generate mode expression =
71 JsExpr $ JS.Float float
71 JsExpr $ JS.Float float
72
72
73 Opt.VarLocal name ->
73 Opt.VarLocal name ->
74− JsExpr $ JS.Ref (Name.fromLocal name)
74+ JsExpr $ JS.Ref (JsName.fromLocal name)
75
75
76 Opt.VarGlobal (Opt.Global home name) ->
76 Opt.VarGlobal (Opt.Global home name) ->
77− JsExpr $ JS.Ref (Name.fromGlobal home name)
77+ JsExpr $ JS.Ref (JsName.fromGlobal home name)
78
78
79 Opt.VarEnum (Opt.Global home name) index ->
79 Opt.VarEnum (Opt.Global home name) index ->
80 case mode of
80 case mode of
81 Mode.Dev _ _ ->
81 Mode.Dev _ _ ->
82− JsExpr $ JS.Ref (Name.fromGlobal home name)
82+ JsExpr $ JS.Ref (JsName.fromGlobal home name)
83
83
84 Mode.Prod _ _ ->
84 Mode.Prod _ _ ->
85 JsExpr $ JS.Int (Index.toMachine index)
85 JsExpr $ JS.Int (Index.toMachine index)
@@ -87,32 +87,32 @@ generate mode expression =
87 Opt.VarBox (Opt.Global home name) ->
87 Opt.VarBox (Opt.Global home name) ->
88 JsExpr $ JS.Ref $
88 JsExpr $ JS.Ref $
89 case mode of
89 case mode of
90− Mode.Dev _ _ -> Name.fromGlobal home name
90+ Mode.Dev _ _ -> JsName.fromGlobal home name
91− Mode.Prod _ _ -> Name.fromGlobal ModuleName.basics N.identity
91+ Mode.Prod _ _ -> JsName.fromGlobal ModuleName.basics Name.identity
92
92
93 Opt.VarCycle home name ->
93 Opt.VarCycle home name ->
94− JsExpr $ JS.Call (JS.Ref (Name.fromCycle home name)) []
94+ JsExpr $ JS.Call (JS.Ref (JsName.fromCycle home name)) []
95
95
96 Opt.VarDebug name home region unhandledValueName ->
96 Opt.VarDebug name home region unhandledValueName ->
97 JsExpr $ generateDebug name home region unhandledValueName
97 JsExpr $ generateDebug name home region unhandledValueName
98
98
99 Opt.VarKernel home name ->
99 Opt.VarKernel home name ->
100− JsExpr $ JS.Ref (Name.fromKernel home name)
100+ JsExpr $ JS.Ref (JsName.fromKernel home name)
101
101
102 Opt.List entries ->
102 Opt.List entries ->
103 case entries of
103 case entries of
104 [] ->
104 [] ->
105− JsExpr $ JS.Ref (Name.fromKernel N.list "Nil")
105+ JsExpr $ JS.Ref (JsName.fromKernel Name.list "Nil")
106
106
107 _ ->
107 _ ->
108 JsExpr $
108 JsExpr $
109 JS.Call
109 JS.Call
110− (JS.Ref (Name.fromKernel N.list "fromArray"))
110+ (JS.Ref (JsName.fromKernel Name.list "fromArray"))
111 [ JS.Array $ map (generateJsExpr mode) entries
111 [ JS.Array $ map (generateJsExpr mode) entries
112 ]
112 ]
113
113
114 Opt.Function args body ->
114 Opt.Function args body ->
115− generateFunction (map Name.fromLocal args) (generate mode body)
115+ generateFunction (map JsName.fromLocal args) (generate mode body)
116
116
117 Opt.Call func args ->
117 Opt.Call func args ->
118 JsExpr $ generateCall mode func args
118 JsExpr $ generateCall mode func args
@@ -130,7 +130,7 @@ generate mode expression =
130 Opt.Destruct (Opt.Destructor name path) body ->
130 Opt.Destruct (Opt.Destructor name path) body ->
131 let
131 let
132 pathExpr = generatePath mode path
132 pathExpr = generatePath mode path
133− pathDef = JS.Var [ (Name.fromLocal name, Just pathExpr) ]
133+ pathDef = JS.Var [ (JsName.fromLocal name, Just pathExpr) ]
134 in
134 in
135 JsBlock $ pathDef : codeToStmtList (generate mode body)
135 JsBlock $ pathDef : codeToStmtList (generate mode body)
136
136
@@ -138,9 +138,9 @@ generate mode expression =
138 JsBlock $ generateCase mode label root decider jumps
138 JsBlock $ generateCase mode label root decider jumps
139
139
140 Opt.Accessor field ->
140 Opt.Accessor field ->
141− JsExpr $ JS.Function Nothing [Name.dollar]
141+ JsExpr $ JS.Function Nothing [JsName.dollar]
142 [ JS.Return $ Just $
142 [ JS.Return $ Just $
143− JS.Access (JS.Ref Name.dollar) (generateField mode field)
143+ JS.Access (JS.Ref JsName.dollar) (generateField mode field)
144 ]
144 ]
145
145
146 Opt.Access record field ->
146 Opt.Access record field ->
@@ -148,7 +148,7 @@ generate mode expression =
148
148
149 Opt.Update record fields ->
149 Opt.Update record fields ->
150 JsExpr $
150 JsExpr $
151− JS.Call (JS.Ref (Name.fromKernel N.utils "update"))
151+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "update"))
152 [ generateJsExpr mode record
152 [ generateJsExpr mode record
153 , generateRecord mode fields
153 , generateRecord mode fields
154 ]
154 ]
@@ -159,7 +159,7 @@ generate mode expression =
159 Opt.Unit ->
159 Opt.Unit ->
160 case mode of
160 case mode of
161 Mode.Dev _ _ ->
161 Mode.Dev _ _ ->
162− JsExpr $ JS.Ref (Name.fromKernel N.utils "Tuple0")
162+ JsExpr $ JS.Ref (JsName.fromKernel Name.utils "Tuple0")
163
163
164 Mode.Prod _ _ ->
164 Mode.Prod _ _ ->
165 JsExpr $ JS.Int 0
165 JsExpr $ JS.Int 0
@@ -168,13 +168,13 @@ generate mode expression =
168 JsExpr $
168 JsExpr $
169 case maybeC of
169 case maybeC of
170 Nothing ->
170 Nothing ->
171− JS.Call (JS.Ref (Name.fromKernel N.utils "Tuple2"))
171+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "Tuple2"))
172 [ generateJsExpr mode a
172 [ generateJsExpr mode a
173 , generateJsExpr mode b
173 , generateJsExpr mode b
174 ]
174 ]
175
175
176 Just c ->
176 Just c ->
177− JS.Call (JS.Ref (Name.fromKernel N.utils "Tuple3"))
177+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "Tuple3"))
178 [ generateJsExpr mode a
178 [ generateJsExpr mode a
179 , generateJsExpr mode b
179 , generateJsExpr mode b
180 , generateJsExpr mode c
180 , generateJsExpr mode c
@@ -183,17 +183,17 @@ generate mode expression =
183 Opt.Shader src attributes uniforms ->
183 Opt.Shader src attributes uniforms ->
184 let
184 let
185 toTranlation field =
185 toTranlation field =
186− ( Name.fromLocal field
186+ ( JsName.fromLocal field
187− , JS.String (Name.toBuilder (generateField mode field))
187+ , JS.String (JsName.toBuilder (generateField mode field))
188 )
188 )
189
189
190 toTranslationObject fields =
190 toTranslationObject fields =
191 JS.Object (map toTranlation (Set.toList fields))
191 JS.Object (map toTranlation (Set.toList fields))
192 in
192 in
193 JsExpr $ JS.Object $
193 JsExpr $ JS.Object $
194− [ ( Name.fromLocal "src", JS.String (Text.encodeUtf8Builder src) )
194+ [ ( JsName.fromLocal "src", JS.String (Text.encodeUtf8Builder src) )
195− , ( Name.fromLocal "attributes", toTranslationObject attributes )
195+ , ( JsName.fromLocal "attributes", toTranslationObject attributes )
196− , ( Name.fromLocal "uniforms", toTranslationObject uniforms )
196+ , ( JsName.fromLocal "uniforms", toTranslationObject uniforms )
197 ]
197 ]
198
198
199
199
@@ -255,7 +255,7 @@ codeToStmt code =
255{-# NOINLINE toChar #-}
255{-# NOINLINE toChar #-}
256toChar :: JS.Expr
256toChar :: JS.Expr
257toChar =
257toChar =
258− JS.Ref (Name.fromKernel N.utils "chr")
258+ JS.Ref (JsName.fromKernel Name.utils "chr")
259
259
260
260
261
261
@@ -266,18 +266,18 @@ generateCtor :: Mode.Mode -> Opt.Global -> Index.ZeroBased -> Int -> Code
266generateCtor mode (Opt.Global home name) index arity =
266generateCtor mode (Opt.Global home name) index arity =
267 let
267 let
268 argNames =
268 argNames =
269− Index.indexedMap (\i _ -> Name.fromIndex i) [1 .. arity]
269+ Index.indexedMap (\i _ -> JsName.fromIndex i) [1 .. arity]
270
270
271 ctorTag =
271 ctorTag =
272 case mode of
272 case mode of
273− Mode.Dev _ _ -> JS.String (N.toBuilder name)
273+ Mode.Dev _ _ -> JS.String (Name.toBuilder name)
274 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
274 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
275 in
275 in
276 generateFunction argNames $ JsExpr $ JS.Object $
276 generateFunction argNames $ JsExpr $ JS.Object $
277− (Name.dollar, ctorTag) : map (\n -> (n, JS.Ref n)) argNames
277+ (JsName.dollar, ctorTag) : map (\n -> (n, JS.Ref n)) argNames
278
278
279
279
280−ctorToInt :: ModuleName.Canonical -> N.Name -> Index.ZeroBased -> Int
280+ctorToInt :: ModuleName.Canonical -> Name.Name -> Index.ZeroBased -> Int
281ctorToInt home name index =
281ctorToInt home name index =
282 if home == ModuleName.dict && name == "RBNode_elm_builtin" || name == "RBEmpty_elm_builtin" then
282 if home == ModuleName.dict && name == "RBNode_elm_builtin" || name == "RBEmpty_elm_builtin" then
283 0 - Index.toHuman index
283 0 - Index.toHuman index
@@ -289,7 +289,7 @@ ctorToInt home name index =
289-- RECORDS
289-- RECORDS
290
290
291
291
292−generateRecord :: Mode.Mode -> Map.Map N.Name Opt.Expr -> JS.Expr
292+generateRecord :: Mode.Mode -> Map.Map Name.Name Opt.Expr -> JS.Expr
293generateRecord mode fields =
293generateRecord mode fields =
294 let
294 let
295 toPair (field, value) =
295 toPair (field, value) =
@@ -298,11 +298,11 @@ generateRecord mode fields =
298 JS.Object (map toPair (Map.toList fields))
298 JS.Object (map toPair (Map.toList fields))
299
299
300
300
301−generateField :: Mode.Mode -> N.Name -> Name.Name
301+generateField :: Mode.Mode -> Name.Name -> JsName.Name
302generateField mode name =
302generateField mode name =
303 case mode of
303 case mode of
304 Mode.Dev _ _ ->
304 Mode.Dev _ _ ->
305− Name.fromLocal name
305+ JsName.fromLocal name
306
306
307 Mode.Prod _ fields ->
307 Mode.Prod _ fields ->
308 fields ! name
308 fields ! name
@@ -313,39 +313,39 @@ generateField mode name =
313-- DEBUG
313-- DEBUG
314
314
315
315
316−generateDebug :: N.Name -> ModuleName.Canonical -> R.Region -> Maybe N.Name -> JS.Expr
316+generateDebug :: Name.Name -> ModuleName.Canonical -> R.Region -> Maybe Name.Name -> JS.Expr
317generateDebug name (ModuleName.Canonical _ home) region unhandledValueName =
317generateDebug name (ModuleName.Canonical _ home) region unhandledValueName =
318 if name /= "todo" then
318 if name /= "todo" then
319− JS.Ref (Name.fromGlobal ModuleName.debug name)
319+ JS.Ref (JsName.fromGlobal ModuleName.debug name)
320 else
320 else
321 case unhandledValueName of
321 case unhandledValueName of
322 Nothing ->
322 Nothing ->
323− JS.Call (JS.Ref (Name.fromKernel N.debug "todo")) $
323+ JS.Call (JS.Ref (JsName.fromKernel Name.debug "todo")) $
324− [ JS.String (N.toBuilder home)
324+ [ JS.String (Name.toBuilder home)
325 , regionToJsExpr region
325 , regionToJsExpr region
326 ]
326 ]
327
327
328 Just valueName ->
328 Just valueName ->
329− JS.Call (JS.Ref (Name.fromKernel N.debug "todoCase")) $
329+ JS.Call (JS.Ref (JsName.fromKernel Name.debug "todoCase")) $
330− [ JS.String (N.toBuilder home)
330+ [ JS.String (Name.toBuilder home)
331 , regionToJsExpr region
331 , regionToJsExpr region
332− , JS.Ref (Name.fromLocal valueName)
332+ , JS.Ref (JsName.fromLocal valueName)
333 ]
333 ]
334
334
335
335
336regionToJsExpr :: R.Region -> JS.Expr
336regionToJsExpr :: R.Region -> JS.Expr
337regionToJsExpr (R.Region start end) =
337regionToJsExpr (R.Region start end) =
338 JS.Object
338 JS.Object
339− [ ( Name.fromLocal "start", positionToJsExpr start )
339+ [ ( JsName.fromLocal "start", positionToJsExpr start )
340− , ( Name.fromLocal "end", positionToJsExpr end )
340+ , ( JsName.fromLocal "end", positionToJsExpr end )
341 ]
341 ]
342
342
343
343
344positionToJsExpr :: R.Position -> JS.Expr
344positionToJsExpr :: R.Position -> JS.Expr
345positionToJsExpr (R.Position line column) =
345positionToJsExpr (R.Position line column) =
346 JS.Object
346 JS.Object
347− [ ( Name.fromLocal "line", JS.Int line )
347+ [ ( JsName.fromLocal "line", JS.Int line )
348− , ( Name.fromLocal "column", JS.Int column )
348+ , ( JsName.fromLocal "column", JS.Int column )
349 ]
349 ]
350
350
351
351
@@ -353,7 +353,7 @@ positionToJsExpr (R.Position line column) =
353-- FUNCTION
353-- FUNCTION
354
354
355
355
356−generateFunction :: [Name.Name] -> Code -> Code
356+generateFunction :: [JsName.Name] -> Code -> Code
357generateFunction args body =
357generateFunction args body =
358 case IntMap.lookup (length args) funcHelpers of
358 case IntMap.lookup (length args) funcHelpers of
359 Just helper ->
359 Just helper ->
@@ -376,7 +376,7 @@ generateFunction args body =
376funcHelpers :: IntMap.IntMap JS.Expr
376funcHelpers :: IntMap.IntMap JS.Expr
377funcHelpers =
377funcHelpers =
378 IntMap.fromList $
378 IntMap.fromList $
379− map (\n -> (n, JS.Ref (Name.makeF n))) [2..9]
379+ map (\n -> (n, JS.Ref (JsName.makeF n))) [2..9]
380
380
381
381
382
382
@@ -413,9 +413,9 @@ generateCallHelp mode func args =
413 (map (generateJsExpr mode) args)
413 (map (generateJsExpr mode) args)
414
414
415
415
416−generateGlobalCall :: ModuleName.Canonical -> N.Name -> [JS.Expr] -> JS.Expr
416+generateGlobalCall :: ModuleName.Canonical -> Name.Name -> [JS.Expr] -> JS.Expr
417generateGlobalCall home name args =
417generateGlobalCall home name args =
418− generateNormalCall (JS.Ref (Name.fromGlobal home name)) args
418+ generateNormalCall (JS.Ref (JsName.fromGlobal home name)) args
419
419
420
420
421generateNormalCall :: JS.Expr -> [JS.Expr] -> JS.Expr
421generateNormalCall :: JS.Expr -> [JS.Expr] -> JS.Expr
@@ -432,7 +432,7 @@ generateNormalCall func args =
432callHelpers :: IntMap.IntMap JS.Expr
432callHelpers :: IntMap.IntMap JS.Expr
433callHelpers =
433callHelpers =
434 IntMap.fromList $
434 IntMap.fromList $
435− map (\n -> (n, JS.Ref (Name.makeA n))) [2..9]
435+ map (\n -> (n, JS.Ref (JsName.makeA n))) [2..9]
436
436
437
437
438
438
@@ -441,36 +441,36 @@ callHelpers =
441
441
442generateCoreCall :: Mode.Mode -> Opt.Global -> [Opt.Expr] -> JS.Expr
442generateCoreCall :: Mode.Mode -> Opt.Global -> [Opt.Expr] -> JS.Expr
443generateCoreCall mode (Opt.Global home@(ModuleName.Canonical _ moduleName) name) args =
443generateCoreCall mode (Opt.Global home@(ModuleName.Canonical _ moduleName) name) args =
444− if moduleName == N.basics then
444+ if moduleName == Name.basics then
445 generateBasicsCall mode home name args
445 generateBasicsCall mode home name args
446
446
447− else if moduleName == N.bitwise then
447+ else if moduleName == Name.bitwise then
448 generateBitwiseCall home name (map (generateJsExpr mode) args)
448 generateBitwiseCall home name (map (generateJsExpr mode) args)
449
449
450− else if moduleName == N.tuple then
450+ else if moduleName == Name.tuple then
451 generateTupleCall home name (map (generateJsExpr mode) args)
451 generateTupleCall home name (map (generateJsExpr mode) args)
452
452
453− else if moduleName == N.jsArray then
453+ else if moduleName == Name.jsArray then
454 generateJsArrayCall home name (map (generateJsExpr mode) args)
454 generateJsArrayCall home name (map (generateJsExpr mode) args)
455
455
456 else
456 else
457 generateGlobalCall home name (map (generateJsExpr mode) args)
457 generateGlobalCall home name (map (generateJsExpr mode) args)
458
458
459
459
460−generateTupleCall :: ModuleName.Canonical -> N.Name -> [JS.Expr] -> JS.Expr
460+generateTupleCall :: ModuleName.Canonical -> Name.Name -> [JS.Expr] -> JS.Expr
461generateTupleCall home name args =
461generateTupleCall home name args =
462 case args of
462 case args of
463 [value] ->
463 [value] ->
464 case name of
464 case name of
465− "first" -> JS.Access value (Name.fromLocal "a")
465+ "first" -> JS.Access value (JsName.fromLocal "a")
466− "second" -> JS.Access value (Name.fromLocal "b")
466+ "second" -> JS.Access value (JsName.fromLocal "b")
467 _ -> generateGlobalCall home name args
467 _ -> generateGlobalCall home name args
468
468
469 _ ->
469 _ ->
470 generateGlobalCall home name args
470 generateGlobalCall home name args
471
471
472
472
473−generateJsArrayCall :: ModuleName.Canonical -> N.Name -> [JS.Expr] -> JS.Expr
473+generateJsArrayCall :: ModuleName.Canonical -> Name.Name -> [JS.Expr] -> JS.Expr
474generateJsArrayCall home name args =
474generateJsArrayCall home name args =
475 case args of
475 case args of
476 [entry] | name == "singleton" -> JS.Array [entry]
476 [entry] | name == "singleton" -> JS.Array [entry]
@@ -478,7 +478,7 @@ generateJsArrayCall home name args =
478 _ -> generateGlobalCall home name args
478 _ -> generateGlobalCall home name args
479
479
480
480
481−generateBitwiseCall :: ModuleName.Canonical -> N.Name -> [JS.Expr] -> JS.Expr
481+generateBitwiseCall :: ModuleName.Canonical -> Name.Name -> [JS.Expr] -> JS.Expr
482generateBitwiseCall home name args =
482generateBitwiseCall home name args =
483 case args of
483 case args of
484 [arg] ->
484 [arg] ->
@@ -500,7 +500,7 @@ generateBitwiseCall home name args =
500 generateGlobalCall home name args
500 generateGlobalCall home name args
501
501
502
502
503−generateBasicsCall :: Mode.Mode -> ModuleName.Canonical -> N.Name -> [Opt.Expr] -> JS.Expr
503+generateBasicsCall :: Mode.Mode -> ModuleName.Canonical -> Name.Name -> [Opt.Expr] -> JS.Expr
504generateBasicsCall mode home name args =
504generateBasicsCall mode home name args =
505 case args of
505 case args of
506 [elmArg] ->
506 [elmArg] ->
@@ -551,7 +551,7 @@ equal left right =
551 if isLiteral left || isLiteral right then
551 if isLiteral left || isLiteral right then
552 strictEq left right
552 strictEq left right
553 else
553 else
554− JS.Call (JS.Ref (Name.fromKernel N.utils "eq")) [left, right]
554+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "eq")) [left, right]
555
555
556
556
557notEqual :: JS.Expr -> JS.Expr -> JS.Expr
557notEqual :: JS.Expr -> JS.Expr -> JS.Expr
@@ -560,7 +560,7 @@ notEqual left right =
560 strictNEq left right
560 strictNEq left right
561 else
561 else
562 JS.Prefix JS.PrefixLNot $
562 JS.Prefix JS.PrefixLNot $
563− JS.Call (JS.Ref (Name.fromKernel N.utils "eq")) [left, right]
563+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "eq")) [left, right]
564
564
565
565
566cmp :: JS.InfixOp -> JS.InfixOp -> Int -> JS.Expr -> JS.Expr -> JS.Expr
566cmp :: JS.InfixOp -> JS.InfixOp -> Int -> JS.Expr -> JS.Expr -> JS.Expr
@@ -569,7 +569,7 @@ cmp idealOp backupOp backupInt left right =
569 JS.Infix idealOp left right
569 JS.Infix idealOp left right
570 else
570 else
571 JS.Infix backupOp
571 JS.Infix backupOp
572− (JS.Call (JS.Ref (Name.fromKernel N.utils "cmp")) [left, right])
572+ (JS.Call (JS.Ref (JsName.fromKernel Name.utils "cmp")) [left, right])
573 (JS.Int backupInt)
573 (JS.Int backupInt)
574
574
575
575
@@ -616,7 +616,7 @@ append mode left right =
616
616
617jsAppend :: JS.Expr -> JS.Expr -> JS.Expr
617jsAppend :: JS.Expr -> JS.Expr -> JS.Expr
618jsAppend a b =
618jsAppend a b =
619− JS.Call (JS.Ref (Name.fromKernel N.utils "ap")) [a, b]
619+ JS.Call (JS.Ref (JsName.fromKernel Name.utils "ap")) [a, b]
620
620
621
621
622toSeqs :: Mode.Mode -> Opt.Expr -> [JS.Expr]
622toSeqs :: Mode.Mode -> Opt.Expr -> [JS.Expr]
@@ -692,19 +692,19 @@ strictNEq left right =
692
692
693-- TODO check if JS minifiers collapse unnecessary temporary variables
693-- TODO check if JS minifiers collapse unnecessary temporary variables
694--
694--
695−generateTailCall :: Mode.Mode -> N.Name -> [(N.Name, Opt.Expr)] -> [JS.Stmt]
695+generateTailCall :: Mode.Mode -> Name.Name -> [(Name.Name, Opt.Expr)] -> [JS.Stmt]
696generateTailCall mode name args =
696generateTailCall mode name args =
697 let
697 let
698 toTempVars (argName, arg) =
698 toTempVars (argName, arg) =
699− ( Name.makeTemp argName, Just (generateJsExpr mode arg) )
699+ ( JsName.makeTemp argName, Just (generateJsExpr mode arg) )
700
700
701 toRealVars (argName, _) =
701 toRealVars (argName, _) =
702 JS.ExprStmt $
702 JS.ExprStmt $
703− JS.Assign (JS.LRef (Name.fromLocal argName)) (JS.Ref (Name.makeTemp argName))
703+ JS.Assign (JS.LRef (JsName.fromLocal argName)) (JS.Ref (JsName.makeTemp argName))
704 in
704 in
705 JS.Var (map toTempVars args)
705 JS.Var (map toTempVars args)
706 : map toRealVars args
706 : map toRealVars args
707− ++ [ JS.Continue (Just (Name.fromLocal name)) ]
707+ ++ [ JS.Continue (Just (JsName.fromLocal name)) ]
708
708
709
709
710
710
@@ -715,16 +715,16 @@ generateDef :: Mode.Mode -> Opt.Def -> JS.Stmt
715generateDef mode def =
715generateDef mode def =
716 case def of
716 case def of
717 Opt.Def name body ->
717 Opt.Def name body ->
718− JS.Var [ (Name.fromLocal name, Just (generateJsExpr mode body)) ]
718+ JS.Var [ (JsName.fromLocal name, Just (generateJsExpr mode body)) ]
719
719
720 Opt.TailDef name argNames body ->
720 Opt.TailDef name argNames body ->
721− JS.Var [ (Name.fromLocal name, Just (codeToExpr (generateTailDef mode name argNames body))) ]
721+ JS.Var [ (JsName.fromLocal name, Just (codeToExpr (generateTailDef mode name argNames body))) ]
722
722
723
723
724−generateTailDef :: Mode.Mode -> N.Name -> [N.Name] -> Opt.Expr -> Code
724+generateTailDef :: Mode.Mode -> Name.Name -> [Name.Name] -> Opt.Expr -> Code
725generateTailDef mode name argNames body =
725generateTailDef mode name argNames body =
726− generateFunction (map Name.fromLocal argNames) $ JsBlock $
726+ generateFunction (map JsName.fromLocal argNames) $ JsBlock $
727− [ JS.Labelled (Name.fromLocal name) $
727+ [ JS.Labelled (JsName.fromLocal name) $
728 JS.While (JS.Bool True) $
728 JS.While (JS.Bool True) $
729 codeToStmt $ generate mode body
729 codeToStmt $ generate mode body
730 ]
730 ]
@@ -738,10 +738,10 @@ generatePath :: Mode.Mode -> Opt.Path -> JS.Expr
738generatePath mode path =
738generatePath mode path =
739 case path of
739 case path of
740 Opt.Index index subPath ->
740 Opt.Index index subPath ->
741− JS.Access (generatePath mode subPath) (Name.fromIndex index)
741+ JS.Access (generatePath mode subPath) (JsName.fromIndex index)
742
742
743 Opt.Root name ->
743 Opt.Root name ->
744− JS.Ref (Name.fromLocal name)
744+ JS.Ref (JsName.fromLocal name)
745
745
746 Opt.Field field subPath ->
746 Opt.Field field subPath ->
747 JS.Access (generatePath mode subPath) (generateField mode field)
747 JS.Access (generatePath mode subPath) (generateField mode field)
@@ -749,7 +749,7 @@ generatePath mode path =
749 Opt.Unbox subPath ->
749 Opt.Unbox subPath ->
750 case mode of
750 case mode of
751 Mode.Dev _ _ ->
751 Mode.Dev _ _ ->
752− JS.Access (generatePath mode subPath) (Name.fromIndex Index.first)
752+ JS.Access (generatePath mode subPath) (JsName.fromIndex Index.first)
753
753
754 Mode.Prod _ _ ->
754 Mode.Prod _ _ ->
755 generatePath mode subPath
755 generatePath mode subPath
@@ -824,30 +824,30 @@ crushIfsHelp visitedBranches unvisitedBranches final =
824-- CASE EXPRESSIONS
824-- CASE EXPRESSIONS
825
825
826
826
827−generateCase :: Mode.Mode -> N.Name -> N.Name -> Opt.Decider Opt.Choice -> [(Int, Opt.Expr)] -> [JS.Stmt]
827+generateCase :: Mode.Mode -> Name.Name -> Name.Name -> Opt.Decider Opt.Choice -> [(Int, Opt.Expr)] -> [JS.Stmt]
828generateCase mode label root decider jumps =
828generateCase mode label root decider jumps =
829 foldr (goto mode label) (generateDecider mode label root decider) jumps
829 foldr (goto mode label) (generateDecider mode label root decider) jumps
830
830
831
831
832−goto :: Mode.Mode -> N.Name -> (Int, Opt.Expr) -> [JS.Stmt] -> [JS.Stmt]
832+goto :: Mode.Mode -> Name.Name -> (Int, Opt.Expr) -> [JS.Stmt] -> [JS.Stmt]
833goto mode label (index, branch) stmts =
833goto mode label (index, branch) stmts =
834 let
834 let
835 labeledDeciderStmt =
835 labeledDeciderStmt =
836 JS.Labelled
836 JS.Labelled
837− (Name.makeLabel label index)
837+ (JsName.makeLabel label index)
838 (JS.While (JS.Bool True) (JS.Block stmts))
838 (JS.While (JS.Bool True) (JS.Block stmts))
839 in
839 in
840 labeledDeciderStmt : codeToStmtList (generate mode branch)
840 labeledDeciderStmt : codeToStmtList (generate mode branch)
841
841
842
842
843−generateDecider :: Mode.Mode -> N.Name -> N.Name -> Opt.Decider Opt.Choice -> [JS.Stmt]
843+generateDecider :: Mode.Mode -> Name.Name -> Name.Name -> Opt.Decider Opt.Choice -> [JS.Stmt]
844generateDecider mode label root decisionTree =
844generateDecider mode label root decisionTree =
845 case decisionTree of
845 case decisionTree of
846 Opt.Leaf (Opt.Inline branch) ->
846 Opt.Leaf (Opt.Inline branch) ->
847 codeToStmtList (generate mode branch)
847 codeToStmtList (generate mode branch)
848
848
849 Opt.Leaf (Opt.Jump index) ->
849 Opt.Leaf (Opt.Jump index) ->
850− [ JS.Break (Just (Name.makeLabel label index)) ]
850+ [ JS.Break (Just (JsName.makeLabel label index)) ]
851
851
852 Opt.Chain testChain success failure ->
852 Opt.Chain testChain success failure ->
853 [ JS.IfStmt
853 [ JS.IfStmt
@@ -867,7 +867,7 @@ generateDecider mode label root decisionTree =
867 ]
867 ]
868
868
869
869
870−generateIfTest :: Mode.Mode -> N.Name -> (DT.Path, DT.Test) -> JS.Expr
870+generateIfTest :: Mode.Mode -> Name.Name -> (DT.Path, DT.Test) -> JS.Expr
871generateIfTest mode root (path, test) =
871generateIfTest mode root (path, test) =
872 let
872 let
873 value = pathToJsExpr mode root path
873 value = pathToJsExpr mode root path
@@ -877,16 +877,16 @@ generateIfTest mode root (path, test) =
877 let
877 let
878 tag =
878 tag =
879 case mode of
879 case mode of
880− Mode.Dev _ _ -> JS.Access value Name.dollar
880+ Mode.Dev _ _ -> JS.Access value JsName.dollar
881 Mode.Prod _ _ ->
881 Mode.Prod _ _ ->
882 case opts of
882 case opts of
883− Can.Normal -> JS.Access value Name.dollar
883+ Can.Normal -> JS.Access value JsName.dollar
884 Can.Enum -> value
884 Can.Enum -> value
885 Can.Unbox -> value
885 Can.Unbox -> value
886 in
886 in
887 strictEq tag $
887 strictEq tag $
888 case mode of
888 case mode of
889− Mode.Dev _ _ -> JS.String (N.toBuilder name)
889+ Mode.Dev _ _ -> JS.String (Name.toBuilder name)
890 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
890 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
891
891
892 DT.IsBool True ->
892 DT.IsBool True ->
@@ -901,25 +901,25 @@ generateIfTest mode root (path, test) =
901 DT.IsChr char ->
901 DT.IsChr char ->
902 strictEq (JS.String (Utf8.toBuilder char)) $
902 strictEq (JS.String (Utf8.toBuilder char)) $
903 case mode of
903 case mode of
904− Mode.Dev _ _ -> JS.Call (JS.Access value (Name.fromLocal "valueOf")) []
904+ Mode.Dev _ _ -> JS.Call (JS.Access value (JsName.fromLocal "valueOf")) []
905 Mode.Prod _ _ -> value
905 Mode.Prod _ _ -> value
906
906
907 DT.IsStr string ->
907 DT.IsStr string ->
908 strictEq value (JS.String (Utf8.toBuilder string))
908 strictEq value (JS.String (Utf8.toBuilder string))
909
909
910 DT.IsCons ->
910 DT.IsCons ->
911− JS.Access value (Name.fromLocal "b")
911+ JS.Access value (JsName.fromLocal "b")
912
912
913 DT.IsNil ->
913 DT.IsNil ->
914 JS.Prefix JS.PrefixLNot $
914 JS.Prefix JS.PrefixLNot $
915− JS.Access value (Name.fromLocal "b")
915+ JS.Access value (JsName.fromLocal "b")
916
916
917 DT.IsTuple ->
917 DT.IsTuple ->
918 error "COMPILER BUG - there should never be tests on a tuple"
918 error "COMPILER BUG - there should never be tests on a tuple"
919
919
920
920
921
921
922−generateCaseBranch :: Mode.Mode -> N.Name -> N.Name -> (DT.Test, Opt.Decider Opt.Choice) -> JS.Case
922+generateCaseBranch :: Mode.Mode -> Name.Name -> Name.Name -> (DT.Test, Opt.Decider Opt.Choice) -> JS.Case
923generateCaseBranch mode label root (test, subTree) =
923generateCaseBranch mode label root (test, subTree) =
924 JS.Case
924 JS.Case
925 (generateCaseValue mode test)
925 (generateCaseValue mode test)
@@ -931,7 +931,7 @@ generateCaseValue mode test =
931 case test of
931 case test of
932 DT.IsCtor home name index _ _ ->
932 DT.IsCtor home name index _ _ ->
933 case mode of
933 case mode of
934− Mode.Dev _ _ -> JS.String (N.toBuilder name)
934+ Mode.Dev _ _ -> JS.String (Name.toBuilder name)
935 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
935 Mode.Prod _ _ -> JS.Int (ctorToInt home name index)
936
936
937 DT.IsInt int ->
937 DT.IsInt int ->
@@ -956,24 +956,24 @@ generateCaseValue mode test =
956 error "COMPILER BUG - there should never be three tests on a tuple"
956 error "COMPILER BUG - there should never be three tests on a tuple"
957
957
958
958
959−generateCaseTest :: Mode.Mode -> N.Name -> DT.Path -> DT.Test -> JS.Expr
959+generateCaseTest :: Mode.Mode -> Name.Name -> DT.Path -> DT.Test -> JS.Expr
960generateCaseTest mode root path exampleTest =
960generateCaseTest mode root path exampleTest =
961 let
961 let
962 value = pathToJsExpr mode root path
962 value = pathToJsExpr mode root path
963 in
963 in
964 case exampleTest of
964 case exampleTest of
965 DT.IsCtor home name _ _ opts ->
965 DT.IsCtor home name _ _ opts ->
966− if name == N.bool && home == ModuleName.basics then
966+ if name == Name.bool && home == ModuleName.basics then
967 value
967 value
968 else
968 else
969 case mode of
969 case mode of
970 Mode.Dev _ _ ->
970 Mode.Dev _ _ ->
971− JS.Access value Name.dollar
971+ JS.Access value JsName.dollar
972
972
973 Mode.Prod _ _ ->
973 Mode.Prod _ _ ->
974 case opts of
974 case opts of
975 Can.Normal ->
975 Can.Normal ->
976− JS.Access value Name.dollar
976+ JS.Access value JsName.dollar
977
977
978 Can.Enum ->
978 Can.Enum ->
979 value
979 value
@@ -990,7 +990,7 @@ generateCaseTest mode root path exampleTest =
990 DT.IsChr _ ->
990 DT.IsChr _ ->
991 case mode of
991 case mode of
992 Mode.Dev _ _ ->
992 Mode.Dev _ _ ->
993− JS.Call (JS.Access value (Name.fromLocal "valueOf")) []
993+ JS.Call (JS.Access value (JsName.fromLocal "valueOf")) []
994
994
995 Mode.Prod _ _ ->
995 Mode.Prod _ _ ->
996 value
996 value
@@ -1012,22 +1012,22 @@ generateCaseTest mode root path exampleTest =
1012-- PATTERN PATHS
1012-- PATTERN PATHS
1013
1013
1014
1014
1015−pathToJsExpr :: Mode.Mode -> N.Name -> DT.Path -> JS.Expr
1015+pathToJsExpr :: Mode.Mode -> Name.Name -> DT.Path -> JS.Expr
1016pathToJsExpr mode root path =
1016pathToJsExpr mode root path =
1017 case path of
1017 case path of
1018 DT.Index index subPath ->
1018 DT.Index index subPath ->
1019− JS.Access (pathToJsExpr mode root subPath) (Name.fromIndex index)
1019+ JS.Access (pathToJsExpr mode root subPath) (JsName.fromIndex index)
1020
1020
1021 DT.Unbox subPath ->
1021 DT.Unbox subPath ->
1022 case mode of
1022 case mode of
1023 Mode.Dev _ _ ->
1023 Mode.Dev _ _ ->
1024− JS.Access (pathToJsExpr mode root subPath) (Name.fromIndex Index.first)
1024+ JS.Access (pathToJsExpr mode root subPath) (JsName.fromIndex Index.first)
1025
1025
1026 Mode.Prod _ _ ->
1026 Mode.Prod _ _ ->
1027 pathToJsExpr mode root subPath
1027 pathToJsExpr mode root subPath
1028
1028
1029 DT.Empty ->
1029 DT.Empty ->
1030− JS.Ref (Name.fromLocal root)
1030+ JS.Ref (JsName.fromLocal root)
1031
1031
1032
1032
1033
1033
@@ -1038,13 +1038,13 @@ generateMain :: Mode.Mode -> ModuleName.Canonical -> Opt.Main -> JS.Expr
1038generateMain mode home main =
1038generateMain mode home main =
1039 case main of
1039 case main of
1040 Opt.Static ->
1040 Opt.Static ->
1041− JS.Ref (Name.fromKernel N.virtualDom "init")
1041+ JS.Ref (JsName.fromKernel Name.virtualDom "init")
1042− # JS.Ref (Name.fromGlobal home "main")
1042+ # JS.Ref (JsName.fromGlobal home "main")
1043 # JS.Int 0
1043 # JS.Int 0
1044 # JS.Int 0
1044 # JS.Int 0
1045
1045
1046 Opt.Dynamic msgType decoder ->
1046 Opt.Dynamic msgType decoder ->
1047− JS.Ref (Name.fromGlobal home "main")
1047+ JS.Ref (JsName.fromGlobal home "main")
1048 # generateJsExpr mode decoder
1048 # generateJsExpr mode decoder
1049 # toDebugMetadata mode msgType
1049 # toDebugMetadata mode msgType
1050
1050
compiler/src/Generate/JavaScript/Mode.hs+8−8
@@ -13,11 +13,11 @@ module Generate.JavaScript.Mode
13import qualified Data.List as List
13import qualified Data.List as List
14import qualified Data.Map as Map
14import qualified Data.Map as Map
15import qualified Data.Maybe as Maybe
15import qualified Data.Maybe as Maybe
16+import qualified Data.Name as Name
16
17
17import qualified AST.Optimized as Opt
18import qualified AST.Optimized as Opt
18import qualified Elm.Interface as I
19import qualified Elm.Interface as I
19−import qualified Elm.Name as N
20−import qualified Generate.JavaScript.Name as Name
20+import qualified Generate.JavaScript.Name as JsName
21
21
22
22
23
23
@@ -80,27 +80,27 @@ isServerHelp target =
80
80
81
81
82type ShortFieldNames =
82type ShortFieldNames =
83− Map.Map N.Name Name.Name
83+ Map.Map Name.Name JsName.Name
84
84
85
85
86−shortenFieldNames :: Map.Map N.Name Int -> ShortFieldNames
86+shortenFieldNames :: Map.Map Name.Name Int -> ShortFieldNames
87shortenFieldNames frequencies =
87shortenFieldNames frequencies =
88 Map.foldr addToShortNames Map.empty $
88 Map.foldr addToShortNames Map.empty $
89 Map.foldrWithKey addToBuckets Map.empty frequencies
89 Map.foldrWithKey addToBuckets Map.empty frequencies
90
90
91
91
92−addToBuckets :: N.Name -> Int -> Map.Map Int [N.Name] -> Map.Map Int [N.Name]
92+addToBuckets :: Name.Name -> Int -> Map.Map Int [Name.Name] -> Map.Map Int [Name.Name]
93addToBuckets field frequency buckets =
93addToBuckets field frequency buckets =
94 -- TODO try using an IntMap for buckets
94 -- TODO try using an IntMap for buckets
95 Map.insertWith (++) frequency [field] buckets
95 Map.insertWith (++) frequency [field] buckets
96
96
97
97
98−addToShortNames :: [N.Name] -> ShortFieldNames -> ShortFieldNames
98+addToShortNames :: [Name.Name] -> ShortFieldNames -> ShortFieldNames
99addToShortNames fields shortNames =
99addToShortNames fields shortNames =
100 List.foldl' addField shortNames fields
100 List.foldl' addField shortNames fields
101
101
102
102
103−addField :: ShortFieldNames -> N.Name -> ShortFieldNames
103+addField :: ShortFieldNames -> Name.Name -> ShortFieldNames
104addField shortNames field =
104addField shortNames field =
105− let rename = Name.fromInt (Map.size shortNames) in
105+ let rename = JsName.fromInt (Map.size shortNames) in
106 Map.insert field rename shortNames
106 Map.insert field rename shortNames
compiler/src/Generate/JavaScript/Name.hs+38−43
@@ -19,17 +19,14 @@ module Generate.JavaScript.Name
19
19
20
20
21import qualified Data.ByteString.Builder as B
21import qualified Data.ByteString.Builder as B
22−import qualified Data.ByteString.Short as S
23import Data.Monoid ((<>))
22import Data.Monoid ((<>))
24import qualified Data.Map as Map
23import qualified Data.Map as Map
24+import qualified Data.Name as Name
25import qualified Data.Set as Set
25import qualified Data.Set as Set
26−import qualified Data.Text as Text
27−import qualified Data.Text.Encoding as Text
28import Data.Word (Word8)
26import Data.Word (Word8)
29
27
30import qualified AST.Module.Name as ModuleName
28import qualified AST.Module.Name as ModuleName
31import qualified Data.Index as Index
29import qualified Data.Index as Index
32−import qualified Elm.Name as N
33import qualified Elm.Package as Pkg
30import qualified Elm.Package as Pkg
34
31
35
32
@@ -52,38 +49,36 @@ fromIndex index =
52
49
53fromInt :: Int -> Name
50fromInt :: Int -> Name
54fromInt n =
51fromInt n =
55− Name (B.shortByteString (intToAscii n))
52+ Name (Name.toBuilder (intToAscii n))
56
53
57
54
58−fromLocal :: N.Name -> Name
55+fromLocal :: Name.Name -> Name
59fromLocal name =
56fromLocal name =
60 if Set.member name reservedNames then
57 if Set.member name reservedNames then
61− Name ("_" <> N.toBuilder name)
58+ Name ("_" <> Name.toBuilder name)
62 else
59 else
63− Name (N.toBuilder name)
60+ Name (Name.toBuilder name)
64
61
65
62
66−fromGlobal :: ModuleName.Canonical -> N.Name -> Name
63+fromGlobal :: ModuleName.Canonical -> Name.Name -> Name
67−fromGlobal (ModuleName.Canonical (Pkg.Name user project) home) name =
64+fromGlobal (ModuleName.Canonical (Pkg.Name author project) home) name =
68− Name $
65+ Name $ Name.toEscapedBuilder 0x2D {- - -} 0x5F {- _ -} author
69− Text.encodeUtf8Builder (Text.replace "-" "_" user)
66+ <> "$" <> Name.toEscapedBuilder 0x2D {- - -} 0x5F {- _ -} project
70− <> "$" <> Text.encodeUtf8Builder (Text.replace "-" "_" project) -- TODO store this in a better way
67+ <> "$" <> Name.toEscapedBuilder 0x2E {- . -} 0x24 {- $ -} home
71− <> "$" <> N.toDotlessBuilder home
72− <> "$" <> N.toBuilder name
68+ <> "$" <> Name.toBuilder name
73
69
74
70
75−fromCycle :: ModuleName.Canonical -> N.Name -> Name
71+fromCycle :: ModuleName.Canonical -> Name.Name -> Name
76−fromCycle (ModuleName.Canonical (Pkg.Name user project) home) name =
72+fromCycle (ModuleName.Canonical (Pkg.Name author project) home) name =
77− Name $
73+ Name $ Name.toEscapedBuilder 0x2D {- - -} 0x5F {- _ -} author
78− Text.encodeUtf8Builder (Text.replace "-" "_" user)
74+ <> "$" <> Name.toEscapedBuilder 0x2D {- - -} 0x5F {- _ -} project
79− <> "$" <> Text.encodeUtf8Builder (Text.replace "-" "_" project) -- TODO store this in a better way
75+ <> "$" <> Name.toEscapedBuilder 0x2E {- . -} 0x24 {- $ -} home
80− <> "$" <> N.toDotlessBuilder home
81− <> "$cyclic$" <> N.toBuilder name
76+ <> "$cyclic$" <> Name.toBuilder name
82
77
83
78
84−fromKernel :: N.Name -> N.Name -> Name
79+fromKernel :: Name.Name -> Name.Name -> Name
85fromKernel home name =
80fromKernel home name =
86− Name ("_" <> N.toBuilder home <> "_" <> N.toBuilder name)
81+ Name ("_" <> Name.toBuilder home <> "_" <> Name.toBuilder name)
87
82
88
83
89
84
@@ -100,19 +95,19 @@ makeA n =
100 Name ("A" <> B.intDec n)
95 Name ("A" <> B.intDec n)
101
96
102
97
103−makeLabel :: N.Name -> Int -> Name
98+makeLabel :: Name.Name -> Int -> Name
104makeLabel name index =
99makeLabel name index =
105− Name (N.toBuilder name <> "$" <> B.intDec index)
100+ Name (Name.toBuilder name <> "$" <> B.intDec index)
106
101
107
102
108−makeTemp :: N.Name -> Name
103+makeTemp :: Name.Name -> Name
109makeTemp name =
104makeTemp name =
110− Name ("$temp$" <> N.toBuilder name)
105+ Name ("$temp$" <> Name.toBuilder name)
111
106
112
107
113dollar :: Name
108dollar :: Name
114dollar =
109dollar =
115− Name (N.toBuilder N.dollar)
110+ Name (Name.toBuilder Name.dollar)
116
111
117
112
118
113
@@ -120,12 +115,12 @@ dollar =
120
115
121
116
122{-# NOINLINE reservedNames #-}
117{-# NOINLINE reservedNames #-}
123−reservedNames :: Set.Set N.Name
118+reservedNames :: Set.Set Name.Name
124reservedNames =
119reservedNames =
125 Set.union jsReservedWords elmReservedWords
120 Set.union jsReservedWords elmReservedWords
126
121
127
122
128−jsReservedWords :: Set.Set N.Name
123+jsReservedWords :: Set.Set Name.Name
129jsReservedWords =
124jsReservedWords =
130 Set.fromList
125 Set.fromList
131 [ "do", "if", "in"
126 [ "do", "if", "in"
@@ -141,7 +136,7 @@ jsReservedWords =
141 ]
136 ]
142
137
143
138
144−elmReservedWords :: Set.Set N.Name
139+elmReservedWords :: Set.Set Name.Name
145elmReservedWords =
140elmReservedWords =
146 Set.fromList
141 Set.fromList
147 [ "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"
142 [ "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"
@@ -153,16 +148,16 @@ elmReservedWords =
153-- INT TO ASCII
148-- INT TO ASCII
154
149
155
150
156−intToAscii :: Int -> S.ShortByteString
151+intToAscii :: Int -> Name.Name
157intToAscii n =
152intToAscii n =
158 if n < 53 then -- skip $ as a standalone name
153 if n < 53 then -- skip $ as a standalone name
159− S.pack [toByte n]
154+ Name.fromWords [toByte n]
160
155
161 else
156 else
162 intToAsciiHelp 2 (numStartBytes * numInnerBytes) allBadFields (n - 53)
157 intToAsciiHelp 2 (numStartBytes * numInnerBytes) allBadFields (n - 53)
163
158
164
159
165−intToAsciiHelp :: Int -> Int -> [BadFields] -> Int -> S.ShortByteString
160+intToAsciiHelp :: Int -> Int -> [BadFields] -> Int -> Name.Name
166intToAsciiHelp width blockSize badFields n =
161intToAsciiHelp width blockSize badFields n =
167 case badFields of
162 case badFields of
168 [] ->
163 [] ->
@@ -184,10 +179,10 @@ intToAsciiHelp width blockSize badFields n =
184-- UNSAFE INT TO ASCII
179-- UNSAFE INT TO ASCII
185
180
186
181
187−unsafeIntToAscii :: Int -> [Word8] -> Int -> S.ShortByteString
182+unsafeIntToAscii :: Int -> [Word8] -> Int -> Name.Name
188unsafeIntToAscii width bytes n =
183unsafeIntToAscii width bytes n =
189 if width <= 1 then
184 if width <= 1 then
190− S.pack (toByte n : bytes)
185+ Name.fromWords (toByte n : bytes)
191 else
186 else
192 let
187 let
193 (quotient, remainder) =
188 (quotient, remainder) =
@@ -229,27 +224,27 @@ newtype BadFields =
229
224
230
225
231type Renamings =
226type Renamings =
232− Map.Map S.ShortByteString S.ShortByteString
227+ Map.Map Name.Name Name.Name
233
228
234
229
235allBadFields :: [BadFields]
230allBadFields :: [BadFields]
236allBadFields =
231allBadFields =
237 let
232 let
238 add keyword dict =
233 add keyword dict =
239− Map.alter (Just . addRenaming keyword) (N.length keyword) dict
234+ Map.alter (Just . addRenaming keyword) (Name.length keyword) dict
240 in
235 in
241 Map.elems $ Set.foldr add Map.empty jsReservedWords
236 Map.elems $ Set.foldr add Map.empty jsReservedWords
242
237
243
238
244−addRenaming :: N.Name -> Maybe BadFields -> BadFields
239+addRenaming :: Name.Name -> Maybe BadFields -> BadFields
245addRenaming keyword maybeBadFields =
240addRenaming keyword maybeBadFields =
246 let
241 let
247− width = N.length keyword
242+ width = Name.length keyword
248 maxName = numStartBytes * numInnerBytes ^ (width - 1) - 1
243 maxName = numStartBytes * numInnerBytes ^ (width - 1) - 1
249 in
244 in
250 case maybeBadFields of
245 case maybeBadFields of
251 Nothing ->
246 Nothing ->
252− BadFields $ Map.singleton (N.toShort keyword) (unsafeIntToAscii width [] maxName)
247+ BadFields $ Map.singleton keyword (unsafeIntToAscii width [] maxName)
253
248
254 Just (BadFields renamings) ->
249 Just (BadFields renamings) ->
255− BadFields $ Map.insert (N.toShort keyword) (unsafeIntToAscii width [] (maxName - Map.size renamings)) renamings
250+ BadFields $ Map.insert keyword (unsafeIntToAscii width [] (maxName - Map.size renamings)) renamings