Address most of Jame's review comments

Author: pschachte

src/AST.hs

@@ -1600,7 +1600,6 @@ data ModuleImplementation = ModuleImplementation {
     modKnownProcs:: Map Ident (Set ProcSpec), -- ^Procs visible to this module
     modForeignObjects:: Set FilePath,         -- ^Foreign object files used
     modForeignLibs:: Set String               -- ^Foreign libraries used
-    -- modLLVM :: Maybe LLVMAST.Module           -- ^Module's LLVM representation
     } deriving (Generic)
 
 emptyImplementation :: ModuleImplementation
@@ -3432,17 +3431,17 @@ argIsVar ArgVar{} = True
 argIsVar _ = False
 
 
--- | Test if a PrimArg is a compile-time constant.
+-- | Test if a PrimArg is a compile-time constant.  This can include a
+-- compile-time constant pointer to mutable memory, so it doesn't mean
+-- *recursively* constant.
 argIsConst :: PrimArg -> Bool
 argIsConst ArgVar{}            = False
 argIsConst ArgInt{}            = True
 argIsConst ArgFloat{}          = True
 argIsConst ArgString{}         = True
 argIsConst ArgChar{}           = True
 argIsConst (ArgClosure _ as _) = all argIsConst as
--- XXX Should we consider globals to be constants, since they are compile-time
--- constant pointers, even if what they point to might not be constant?
-argIsConst ArgGlobal{}         = False
+argIsConst ArgGlobal{}         = True
 argIsConst ArgUnneeded{}       = True
 argIsConst ArgUndef{}          = False
 

src/AliasAnalysis.hs

@@ -344,10 +344,11 @@ _maybeAliasPrimArgs args = do
         ArgGlobal global ty -> maybeAddressAlias arg ty $ AliasByGlobal global
         _ -> return Nothing
     maybeAddressAlias arg ty item = do
-        isPhantom <- argIsPhantom arg
+        -- isPhantom <- argIsPhantom arg
         rep <- lookupTypeRepresentation ty
         -- Only Pointer type will create alias
-        if not isPhantom && rep == Just Pointer
+        -- if not isPhantom && rep == Just Pointer
+        if rep == Just Pointer
         then return $ Just item
         else return Nothing
 

src/Emit.hs

@@ -22,7 +22,7 @@ import           Config                     (objectExtension, bitcodeExtension,
                                              llvmToObjectCommand,
                                              removeLPVMSection)
 import           Control.Monad ( (>=>), unless )
-import           Control.Monad.Trans        (liftIO)
+import           Control.Monad.Trans        (liftIO, lift)
 import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.State
 import qualified Data.ByteString            as BS
@@ -42,7 +42,7 @@ import           System.IO                  (openFile, hClose, Handle,
                                              IOMode (WriteMode), hPutStrLn)
 import           System.Process             (proc, readCreateProcessWithExitCode)
 import           System.FilePath            ((-<.>))
-import           System.Directory           (getPermissions, writable, doesFileExist)
+import           System.Directory           (getPermissions, writable, doesFileExist, removeFile)
 import           Util                       (createLocalCacheFile)
 import           LLVM
 import Data.String
@@ -86,6 +86,7 @@ emitObjectFile m f = do
             liftIO $ createLocalCacheFile filename
     let (cmd,cmdLine) = llvmToObjectCommand llFilename filename userOptions
     runOSCmd cmd cmdLine
+    lift $ removeFile llFilename
 
 
 -- | With the LLVM AST representation of a LPVM Module, create a
@@ -99,10 +100,11 @@ emitBitcodeFile m f = do
     userOptions <- gets options
     let (cmd,cmdLine) = llvmToBitcodeCommand llFilename filename userOptions
     runOSCmd cmd cmdLine
+    lift $ removeFile llFilename
 
 
--- | With the LLVM AST representation of a LPVM Module, create a target LLVM
--- Assembly file.  This function forms the basis for all LLVM code generation.
+-- | Create a target LLVM Assembly (.ll) file.  This function forms the basis
+-- for all LLVM code generation.
 emitAssemblyFile :: ModSpec -> FilePath -> Compiler FilePath
 emitAssemblyFile m f = do
     let filename = f -<.> Config.assemblyExtension

src/LLVM.hs

@@ -288,9 +288,9 @@ instance Show StaticConstSpec where
     show (ClosureSpec pspec args) = show pspec ++ showArguments args
 
 
--- | If the specified PrimArg is a string constant, add it to the set.  For Wybe
--- strings, add both the Wybe string and the C string, since the Wybe string
--- constant refers to the C string.
+-- | If the specified PrimArg is a string constant or closure with only constant
+-- arguments, add it to the set.  For Wybe strings, add both the Wybe string and
+-- the C string, since the Wybe string constant refers to the C string.
 prescanArg :: PrimArg -> LLVM ()
 prescanArg (ArgString str WybeString _) = do
     recordConst $ WybeStringSpec str
@@ -755,9 +755,9 @@ writeWybeCall wybeProc args pos = do
     (ins,outs,oRefs,iRefs) <- partitionArgsWithRefs args
     unless (List.null iRefs)
      $ shouldnt $ "Wybe call " ++ show wybeProc ++ " with take-reference arg"
-    prefix <- tailMarker False
+    tailKind <- tailMarker False
     if List.null oRefs then
-        writeActualCall wybeProc ins outs prefix
+        writeActualCall wybeProc ins outs tailKind
     else
         deferCall wybeProc ins outs oRefs
 

test-cases/execution/type_generics.wybe

@@ -1,12 +1,12 @@
-def foo(x:T) use !io {
-    ?l = [x]
-    !println(length(l))
-}
+# def foo(x:T) use !io {
+#     ?l = [x]
+#     !println(length(l))
+# }
 
-!foo(1)
-!foo(true)
-!foo(1.0)
-?x = 1.0; !foo(x) 
+# !foo(1)
+# !foo(true)
+# !foo(1.0)
+# ?x = 1.0; !foo(x) 
 
 def {test} foo2(x:T0, ?y:T0) {
     ?l = [x]
@@ -15,7 +15,8 @@ def {test} foo2(x:T0, ?y:T0) {
 
 if {foo2(42, ?y) :: !println(y)}
 ?i = 42; if {foo2(i, ?y) :: !println(y)}
-?f = 1.0; if {foo2(f, ?fx) :: !println(fx)}
+?f = 1.0; if {foo2(f, ?fx) :: !println(fx)
+             | else :: !println "foo2 fails!"}
 if {foo2(1.0, ?x) :: !println(x)}
 if {foo2('a', ?z) :: !println(z)}
 if {foo2(false, ?b) :: !println(b)}