libraries/ghci/GHCi/TH.hs

 {-# LANGUAGE ScopedTypeVariables, StandaloneDeriving, DeriveGeneric,
     TupleSections, RecordWildCards, InstanceSigs, CPP #-}
 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
+{-# OPTIONS_GHC -Wno-warnings-deprecations #-}
+-- TODO We want to import GHC.Internal.Desugar instead of GHC.Desugar when we
+-- can require of the bootstrap compiler to have ghc-internal.
 
 -- |
 -- Running TH splices
@@ -109,7 +112,7 @@ import Data.IORef
 import Data.Map (Map)
 import qualified Data.Map as M
 import Data.Maybe
-import GHC.Desugar
+import GHC.Desugar (AnnotationWrapper(..))
 import qualified GHC.Internal.TH.Syntax as TH
 import Unsafe.Coerce
 

libraries/ghci/ghci.cabal.in

@@ -85,6 +85,10 @@ library
         rts,
         array            == 0.5.*,
         base             >= 4.8 && < 4.21,
+        -- ghc-internal     == @ProjectVersionMunged@01.*
+        -- TODO: Use GHC.Internal.Desugar from ghc-internal instead of ignoring
+        -- the deprecation warning of GHC.Desugar when we require ghc-internal
+        -- of the bootstrap compiler
         ghc-prim         >= 0.5.0 && < 0.12,
         binary           == 0.8.*,
         bytestring       >= 0.10 && < 0.13,

rts/js/mem.js

@@ -1538,7 +1538,7 @@ function h$copyFromHeap(src, buf_d, buf_o, len) {
 
 // malloc and initialize a buffer on the HEAP
 function h$initHeapBufferLen(buf_d, buf_o, len) {
-  var buf_ptr = _malloc(len);
+  var buf_ptr = Module._malloc(len);
   h$copyToHeap(buf_d, buf_o, buf_ptr, len);
   return buf_ptr;
 }
@@ -1555,11 +1555,11 @@ function h$initHeapBuffer(str_d, str_o) {
 // temporarily malloc and initialize a buffer on the HEAP, pass it to the
 // continuation, then release the buffer
 function h$withOutBufferOnHeap(ptr_d, ptr_o, len, cont) {
-  var ptr = _malloc(len);
+  var ptr = Module._malloc(len);
   h$copyToHeap(ptr_d, ptr_o, ptr, len);
   var ret = cont(ptr);
   h$copyFromHeap(ptr, ptr_d, ptr_o, len);
-  _free(ptr);
+  Module._free(ptr);
   return ret;
 }
 
@@ -1567,10 +1567,10 @@ function h$withOutBufferOnHeap(ptr_d, ptr_o, len, cont) {
 // continuation. The buffer is freed from the heap when the continuation
 // returns.
 function h$withCBufferOnHeap(str_d, str_o, len, cont) {
-    var str = _malloc(len);
+    var str = Module._malloc(len);
     if(str_d !== null) h$copyToHeap(str_d, str_o, str, len);
     var ret = cont(str);
-    _free(str);
+    Module._free(str);
     return ret;
 }
 
@@ -1602,16 +1602,16 @@ function h$putHeapAddr(a,o,offset) {
 function h$copyCStringFromHeap(offset) {
   if(offset == 0) return null;
   var len = 0;
-  while(HEAPU8[offset+len] !== 0){ len++; };
+  while(Module.HEAPU8[offset+len] !== 0){ len++; };
   var str = h$newByteArray(len+1);
-  str.u8.set(HEAPU8.subarray(offset,offset+len+1));
+  str.u8.set(Module.HEAPU8.subarray(offset,offset+len+1));
   return str;
 }
 
 // get an array of n pointers from HEAP
 function h$copyPtrArrayFromHeap(offset,n) {
   var ptr = h$newByteArray(4*n);
-  ptr.u8.set(HEAPU8.subarray(offset, offset+4*n));
+  ptr.u8.set(Module.HEAPU8.subarray(offset, offset+4*n));
   return ptr;
 }
 
@@ -1641,13 +1641,15 @@ function h$registerFunPtrOnHeap(funptr_d, funptr_o, ask_ptr, ty, mkfn) {
   // same slot. Warning: this hack doesn't work if addFunction is called in
   // mkfn, but we check this with an assertion.
   if (ask_ptr) {
-    var cb_ptr = getEmptyTableSlot();
+    var cb_ptr = Module.getEmptyTableSlot();
     Module.removeFunction(cb_ptr);
 
     var cb  = mkfn(fun,cb_ptr);
     var ptr = Module.addFunction(cb,ty);
 
-    assert(cb_ptr === ptr, "h$registerJSFunPtrOnHeap: got different pointer offsets: " + cb_ptr + " and " + ptr);
+    if (cb_ptr !== ptr) {
+      throw ("h$registerJSFunPtrOnHeap: got different pointer offsets: " + cb_ptr + " and " + ptr);
+    }
     return ptr;
   }
   else {

rts/rts.cabal

@@ -94,9 +94,6 @@ library
     if arch(javascript)
 
       include-dirs: include
-      -- dummy file to force the build of a .a lib
-      -- FIXME (Luite, 2022-08) do we still need the c-sources file?
-      c-sources: version.c
 
       js-sources:
         js/config.js

testsuite/driver/testlib.py

@@ -1426,9 +1426,24 @@ async def test_common_work(name: TestName, opts,
             if needsTargetWrapper():
                 opts.skip = True
         elif func in [makefile_test, run_command]:
-            # makefile tests aren't necessarily runtime or compile-time
+            # Note [Makefile tests are supposed to be run in all ways]
+            # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            # Makefile tests aren't necessarily runtime or compile-time
             # specific. Assume we can run them in all ways. See #16042 for what
             # happened previously.
+            #
+            # For example, the WASM test environment requires a target wrapper to run tests
+            # which is why Makefile tests are skipped by default. For cases where the
+            # target wrapper is actually not needed we can trigger Makefile tests to run
+            # by using something like `pre_cmd('$MAKE -s --no-print-directory...`.
+            # Examples of this can be found throughout the code.
+            #
+            # Additionally, it is useful to set `multimod_compile` as the running mode
+            # because it provides enough flexibility to specify source names to compile
+            # without wasting time on running.
+            #
+            # `ignore_stdout` and `ignore_stderr` could also be helpful in cases where
+            # all you need is to compare the exit code with 0.
             all_ways = config.compile_ways + config.run_ways
             if needsTargetWrapper():
                 opts.skip = True

testsuite/tests/codeGen/should_run/T24700.hs

+import Data.Int
+
+main = do
+  input <- getLine
+  print (read input - 3000000000 :: Int64)

testsuite/tests/codeGen/should_run/T24700.stdin

+0

testsuite/tests/codeGen/should_run/T24700.stdout

+-3000000000

testsuite/tests/codeGen/should_run/T24893.hs

+import Data.Word
+
+main :: IO ()
+main = print $ 0x8000000000000000 + zero
+
+zero :: Word64
+zero = 0
+{-# NOINLINE zero #-}

testsuite/tests/codeGen/should_run/T24893.stdout

+9223372036854775808

testsuite/tests/codeGen/should_run/all.T

@@ -248,3 +248,5 @@ test('T24664a', normal, compile_and_run, ['-O'])
 test('T24664b', normal, compile_and_run, ['-O'])
 test('CtzClz0', normal, compile_and_run, [''])
 test('T23034', req_c, compile_and_run, ['-O2 T23034_c.c'])
+test('T24700', normal, compile_and_run, ['-O'])
+test('T24893', normal, compile_and_run, ['-O'])

testsuite/tests/driver/T13914/T13914.stdout

@@ -17,7 +17,6 @@ HasCallStack backtrace:
   throwIO, called at libraries/ghc-internal/src/GHC/Internal/IO/Exception.hs:453:5 in ghc-internal:GHC.Internal.IO.Exception
   assert, called at main.hs:3:8 in main:Main
 
-
 With -fignore-asserts
 [1 of 2] Compiling Main             ( main.hs, main.o ) [Optimisation flags changed]
 [2 of 2] Linking main [Objects changed]

testsuite/tests/driver/all.T

@@ -299,7 +299,7 @@ test('T18369', normal, compile, ['-O'])
 test('T21682', normal, compile_fail, ['-Werror=unrecognised-warning-flags -Wfoo'])
 test('FullGHCVersion', normal, compile_and_run, ['-package ghc-boot'])
 test('OneShotTH', req_th, makefile_test, [])
-test('T17481', normal, makefile_test, [])
+test('T17481', js_broken(23013), makefile_test, [])
 test('T20084', normal, makefile_test, [])
 test('RunMode', [req_interp,extra_files(['RunMode/Test.hs'])], run_command, ['{compiler} --run -iRunMode/ -ignore-dot-ghci RunMode.hs -- hello'])
 test('T20439', normal, run_command,

testsuite/tests/driver/recomp011/all.T

@@ -2,5 +2,6 @@
 
 test('recomp011',
      [ extra_files(['Main.hs'])
+     , js_broken(23013)
      ],
      makefile_test, [])

testsuite/tests/exceptions/T25052.hs

+import Control.Exception
+
+main :: IO ()
+main = do
+  let msg = "no trailing whitespace"
+  fail msg `catch` \(e :: SomeException) -> do
+    putStrLn (displayException e)
+

testsuite/tests/exceptions/T25052.stdout

+user error (no trailing whitespace)
+
+Package: ghc-internal
+Module: GHC.Internal.IO.Exception
+Type: IOException

testsuite/tests/exceptions/all.T

+test('T25052', normal, compile_and_run, [''])
+

testsuite/tests/parser/should_compile/T25132.hs

+{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE MultilineStrings #-}
+{-# LANGUAGE RequiredTypeArguments #-}
+
+module T25132 where
+
+import Data.Proxy
+import GHC.TypeLits
+
+singleTypeMultiVal :: Proxy "this is a\nmultiline\nstring"
+singleTypeMultiVal = Proxy @"""
+                            this is a
+                            multiline
+                            string
+                            """
+
+multiTypeSingleVal :: Proxy """
+                            this is a
+                            multiline
+                            string
+                            """
+multiTypeSingleVal = Proxy @"this is a\nmultiline\nstring"
+
+multiTypeMultiVal :: Proxy """
+                           this is a
+                           multiline
+                           string
+                           """
+multiTypeMultiVal = Proxy @"""
+                           this is a
+                           multiline
+                           string
+                           """
+
+k1 :: ()
+k1 = test where
+  test :: "string" ~ """string""" => ()
+  test = ()
+
+k2 :: ()
+k2 = test where
+  test :: ConsSymbol 's' "tring" ~ """string""" => ()
+  test = ()
+
+k3 :: UnconsSymbol "string" ~ Just '( 's', x) => Proxy x
+k3 = test where
+  test :: Proxy """tring"""
+  test = Proxy
+
+k4 :: Proxy "string"
+k4 = Proxy @"""string"""
+
+k5 :: ()
+k5 = test """string""" where
+  test :: forall a -> ()
+  test _ = ()

testsuite/tests/parser/should_compile/all.T

@@ -202,3 +202,5 @@ test('ListTuplePunsFamilies', [expect_broken(23135), extra_files(['ListTuplePuns
 
 
 test('T22155', normal, compile, ['-dsuppress-uniques -ddump-simpl -dsuppress-all -dno-typeable-binds'])
+
+test('T25132', normal, compile, [''])