New injections for forked elm packages, and add hot reloading

.gitmodules

@@ -4,3 +4,19 @@
 [submodule "vendor/elm-format"]
 	path = vendor/elm-format
 	url = [email protected]:lamdera/elm-format.git
+[submodule "extra/package-replacements/elm/virtual-dom"]
+	path = extra/package-replacements/elm/virtual-dom
+	url = [email protected]:lydell/virtual-dom.git
+	branch = hot-reload-stop
+[submodule "extra/package-replacements/elm/browser"]
+	path = extra/package-replacements/elm/browser
+	url = [email protected]:lydell/browser.git
+	branch = lamdera
+[submodule "extra/package-replacements/elm/html"]
+	path = extra/package-replacements/elm/html
+	url = [email protected]:lydell/html.git
+	branch = safe
+[submodule "extra/package-replacements/elm/core"]
+	path = extra/package-replacements/elm/core
+	url = [email protected]:lydell/core.git
+	branch = lamdera

builder/src/Elm/Details.hs

@@ -63,6 +63,8 @@ import qualified Stuff
 import qualified Lamdera
 import Lamdera ((&))
 import qualified Lamdera.Extensions
+import qualified Lamdera.PackageReplacements
+import qualified Lamdera.Version
 
 -- DETAILS
 
@@ -405,7 +407,7 @@ verifyDep (Env key _ _ cache manager _ _) depsMVar solution pkg details@(Solver.
         then
           do  Reporting.report key Reporting.DCached
               maybeCache <- File.readBinary (Stuff.package cache pkg vsn </> "artifacts.dat")
-                              & Lamdera.alternativeImplementation (File.readBinary (Stuff.package cache pkg vsn </> "artifacts.x.dat"))
+                              & Lamdera.alternativeImplementation (File.readBinary (Stuff.package cache pkg vsn </> Lamdera.Version.artifacts))
               case maybeCache of
                 Nothing ->
                   build key cache depsMVar pkg details fingerprint Set.empty
@@ -500,7 +502,7 @@ build key cache depsMVar pkg (Solver.Details vsn _) f fs =
                                 Just results ->
                                   let
                                     path = Stuff.package cache pkg vsn </> "artifacts.dat"
-                                             & Lamdera.alternativeImplementation (Stuff.package cache pkg vsn </> "artifacts.x.dat")
+                                             & Lamdera.alternativeImplementation (Stuff.package cache pkg vsn </> Lamdera.Version.artifacts)
                                     ifaces = gatherInterfaces exposedDict results
                                     objects = gatherObjects results
                                     artifacts = Artifacts ifaces objects
@@ -622,6 +624,7 @@ crawlModule foreignDeps mvar pkg src docsStatus name =
 crawlFile :: Map.Map ModuleName.Raw ForeignInterface -> MVar StatusDict -> Pkg.Name -> FilePath -> DocsStatus -> ModuleName.Raw -> FilePath -> IO (Maybe Status)
 crawlFile foreignDeps mvar pkg src docsStatus expectedName path =
   do  bytes <- File.readUtf8 path
+               & Lamdera.alternativeImplementationPassthrough (Lamdera.PackageReplacements.getReplacement pkg expectedName)
       case Parse.fromByteString (Parse.Package pkg) bytes of
         Right modul@(Src.Module (Just (A.At _ actualName)) _ _ imports _ _ _ _ _) | expectedName == actualName ->
           do  deps <- crawlImports foreignDeps mvar pkg src imports
@@ -649,6 +652,7 @@ crawlKernel foreignDeps mvar pkg src name =
       if exists
         then
           do  bytes <- File.readUtf8 path
+                       & Lamdera.alternativeImplementationPassthrough (Lamdera.PackageReplacements.getReplacement pkg name)
               case Kernel.fromByteString pkg (Map.mapMaybe getDepHome foreignDeps) bytes of
                 Nothing ->
                   return Nothing

builder/src/Elm/Outline.hs

@@ -219,7 +219,7 @@ read root shouldCheckLamdera =
                           do  maybeDups <- detectDuplicates root (NE.toList srcDirs)
                               case maybeDups of
                                 Nothing ->
-                                  Lamdera.alternativeImplementationPassthrough (Lamdera.Checks.runChecks root shouldCheckLamdera direct) $
+                                  Lamdera.alternativeImplementationPassthrough (Lamdera.Checks.runChecks root shouldCheckLamdera direct indirect) $
                                   return $ Right outline
 
                                 Just (canonicalDir, (dir1,dir2)) ->

builder/src/Reporting/Exit.hs

@@ -68,6 +68,7 @@ import qualified Reporting.Render.Code as Code
 import Lamdera
 import qualified Lamdera.Error
 import qualified Elm.Constraint as Con
+import qualified Lamdera.Version
 
 -- RENDERERS
 
@@ -961,6 +962,8 @@ data Outline
   | OutlineNoAppCore
   | OutlineNoAppJson
   | OutlineLamderaMissingDeps
+  | OutlineLamderaReplacementPackageVersionTooLow Pkg.Name V.Version V.Version
+  | OutlineLamderaReplacementPackageVersionTooHigh Pkg.Name V.Version V.Version
 
 
 data OutlineProblem
@@ -1061,6 +1064,25 @@ toOutlineReport problem =
         , D.reflow "Note: if you're trying to run a normal Elm app, use the elm binary instead."
         ]
 
+    OutlineLamderaReplacementPackageVersionTooLow name replacedVersion elmJsonVersion ->
+      Help.report "UNSUPPORTED VERSION" (Just "elm.json")
+        ("This version of the Lamdera compiler supports the following range for \"" <> Pkg.toChars name <> "\":")
+        [ D.indent 4 $ D.green $ "\"" <> D.fromVersion (Lamdera.Version.resetPatch replacedVersion) <> " <= v <= " <> D.fromVersion replacedVersion <> "\""
+        , D.reflow "But your elm.json contains:"
+        , D.indent 4 $ D.red $ "\"" <> D.fromPackage name <> "\": \"" <> D.fromVersion elmJsonVersion <> "\""
+        , D.reflow "You need to update that package!"
+        ]
+
+    OutlineLamderaReplacementPackageVersionTooHigh name replacedVersion elmJsonVersion ->
+      Help.report "UNSUPPORTED VERSION" (Just "elm.json")
+        ("This version of the Lamdera compiler supports the following range for \"" <> Pkg.toChars name <> "\":")
+        [ D.indent 4 $ D.green $ "\"" <> D.fromVersion (Lamdera.Version.resetPatch replacedVersion) <> " <= v <= " <> D.fromVersion replacedVersion <> "\""
+        , D.reflow "But your elm.json contains:"
+        , D.indent 4 $ D.red $ "\"" <> D.fromPackage name <> "\": \"" <> D.fromVersion elmJsonVersion <> "\""
+        , D.reflow "You need to update the Lamdera compiler. And if there is no later version, ask the Lamdera community to release a new version!"
+        , D.reflow "You can also downgrade that package for now."
+        ]
+
 
 toOutlineProblemReport :: FilePath -> Code.Source -> Json.Context -> A.Region -> OutlineProblem -> Help.Report
 toOutlineProblemReport path source _ region problem =

builder/src/Stuff.hs

@@ -36,13 +36,15 @@ import qualified Elm.Version as V
 
 import Lamdera ((&))
 import qualified Lamdera
+import qualified Lamdera.Version
 
 -- PATHS
 
 
 stuff :: FilePath -> FilePath
 stuff root =
   root </> "elm-stuff" </> compilerVersion
+  & Lamdera.alternativeImplementation (root </> "elm-stuff" </> Lamdera.Version.medium)
 
 
 details :: FilePath -> FilePath

compiler/src/Elm/Package.hs

@@ -31,6 +31,7 @@ module Elm.Package
   , lamderaContainers
   , time
   , bytes
+  , toName
   )
   where
 

compiler/src/Generate/Html.hs

@@ -84,7 +84,7 @@ sandwich_ root moduleName javascript =
 
 <body>
 
-<pre id="elm"></pre>
+<pre data-elm id="elm"></pre>
 
 <script>
 try {

compiler/src/Generate/JavaScript.hs

@@ -48,6 +48,7 @@ generate mode (Opt.GlobalGraph graph_ _) mains =
     graph = Lamdera.Injection.graphModifications mode mains graph_
     state = Map.foldrWithKey (addMain mode graph) emptyState mains
   in
+  Lamdera.Injection.versionsComment <>
   "(function(scope){\n'use strict';"
   <> Functions.functions
   -- <> perfNote mode -- @NOTE given user never manages JS generation in Lamdera, hide the perf note

elm.cabal

@@ -260,6 +260,8 @@ Executable lamdera
         Lamdera.Make
         Lamdera.Nitpick.DebugLog
         Lamdera.Offline
+        Lamdera.PackageReplacements
+        Lamdera.PackageReplacementsTH
         Lamdera.PostCompile
         Lamdera.Project
         Lamdera.Relative

extra/Lamdera/CLI/Reset.hs

@@ -58,8 +58,7 @@ run () () = do
           progress $ "Removing artifacts in " <> elmHome
           let packageDir = elmHome </> Lamdera.Version.elm </> "packages"
           onlyWhen_ (doesDirectoryExist packageDir) $ do
-            callCommand $ "find " <> packageDir <> " | grep artifacts.dat | xargs rm -r"
-            callCommand $ "find " <> packageDir <> " | grep artifacts.x.dat | xargs rm -r"
+            callCommand $ "find " <> packageDir <> " | grep 'artifacts.*\\.dat' | xargs rm -r"
         else do
           nukeDir elmHome
 

extra/Lamdera/Checks.hs

@@ -30,19 +30,26 @@ import Lamdera
 import Lamdera.Progress
 import qualified Lamdera.Init
 import qualified Ext.Common
+import qualified Lamdera.PackageReplacements as PackageReplacements
+import Data.Foldable (traverse_)
 
 
-runChecks :: FilePath -> Bool -> Map.Map Pkg.Name V.Version -> IO (Either Exit.Outline outline) -> IO (Either Exit.Outline outline)
-runChecks root shouldCheckLamdera direct default_ = do
+runChecks :: FilePath -> Bool -> Map.Map Pkg.Name V.Version -> Map.Map Pkg.Name V.Version -> IO (Either Exit.Outline outline) -> IO (Either Exit.Outline outline)
+runChecks root shouldCheckLamdera direct indirect default_ = do
   -- atomicPutStrLn $ "runchecks but with " <> show shouldCheckLamdera
-  if Map.member Pkg.lamderaCore direct
-    then do
-      onlyWhen shouldCheckLamdera (Lamdera.Checks.runChecks_ root)
-      default_
-    else
-      if shouldCheckLamdera
-        then return $ Left Exit.OutlineLamderaMissingDeps
-        else default_
+  case checkPackageReplacementsVersions (Map.union direct indirect) of
+    Left err ->
+      return $ Left err
+
+    Right () ->
+      if Map.member Pkg.lamderaCore direct
+        then do
+          onlyWhen shouldCheckLamdera (Lamdera.Checks.runChecks_ root)
+          default_
+        else
+          if shouldCheckLamdera
+            then return $ Left Exit.OutlineLamderaMissingDeps
+            else default_
 
 
 runChecks_ :: FilePath -> IO ()
@@ -144,3 +151,43 @@ checkMsgHasTypes typeNames = do
     results = fmap (\search -> T.isInfixOf ("type " <> search) source) typeNames
 
   pure $ Prelude.all ((==) True) results
+
+checkPackageReplacementsVersions :: Map.Map Pkg.Name V.Version -> Either Exit.Outline ()
+checkPackageReplacementsVersions allDeps =
+  traverse_ (checkPackageReplacementVersion allDeps) (Map.toList PackageReplacements.versions)
+
+checkPackageReplacementVersion :: Map.Map Pkg.Name V.Version -> ( Pkg.Name, ( V.Version, String ) ) -> Either Exit.Outline ()
+checkPackageReplacementVersion allDeps ( name, ( replacedVersion@(V.Version replacedMajor replacedMinor replacedPatch), _ ) ) =
+  case Map.lookup name allDeps of
+    Nothing ->
+      Right ()
+
+    Just elmJsonVersion@(V.Version elmJsonMajor elmJsonMinor elmJsonPatch) ->
+      -- 🤷 This can’t happen. Only 1.x versions exists of all elm/* packages we replace. But we code it to be a hard error.
+      if elmJsonMajor < replacedMajor then
+        Left (Exit.OutlineLamderaReplacementPackageVersionTooLow name replacedVersion elmJsonVersion)
+
+      -- ❌ It’s very unlikely that Evan will suddenly release 2.x of some package. But if that happens, this should be a hard error.
+      else if elmJsonMajor > replacedMajor then
+        Left (Exit.OutlineLamderaReplacementPackageVersionTooHigh name replacedVersion elmJsonVersion)
+
+      -- 🤷 This can’t happen. Only 1.0.x versions exists of all elm/* packages we replace. But we code it to be a hard error.
+      else if elmJsonMinor < replacedMinor then
+        Left (Exit.OutlineLamderaReplacementPackageVersionTooLow name replacedVersion elmJsonVersion)
+
+      -- ❌ It’s unlikely that Evan will suddenly release 1.1.x of some package. But if that happens, this should be a hard error.
+      else if elmJsonMinor > replacedMinor then
+        Left (Exit.OutlineLamderaReplacementPackageVersionTooHigh name replacedVersion elmJsonVersion)
+
+      -- ✅ This is very likely to happen. Lots of people probably have "elm/virtual-dom": "1.0.3" in their elm.json, and haven’t bothered updating to the more recent 1.0.4 version. If we made this a hard error, it would be annoying for lots of people. It’s better to simply allow the fork patch version to be greater than specified.
+      else if elmJsonPatch < replacedPatch then
+        Right ()
+
+      -- 🚨 This is somewhat likely. As mentioned, elm/virtual-dom 1.0.4 was released, and a little bit later 1.0.5 was released with a security fix. If a user tries to put "elm/virtual-dom": "1.0.5" in their elm.json, I should be a hard error, informing them that you can’t go above 1.0.4 with this release of the Lamdera compiler. (Silently using 1.0.4 anyway would be misleading, leading to a false sense of security.) They need to wait for a new Lamdera compiler version that has pulled in the security fix. (This is an example – the Lamdera compiler did support the latest version (1.0.5) at the time of writing.)
+      else if elmJsonPatch > replacedPatch then
+        Left (Exit.OutlineLamderaReplacementPackageVersionTooHigh name replacedVersion elmJsonVersion)
+
+      -- The version matches exactly.
+      else
+        Right ()
+