OK, fix one at a time

wasm-calc12/src/Calc/Ability/Check.hs

@@ -14,12 +14,12 @@ module Calc.Ability.Check
   )
 where
 
-import Calc.Types.Identifier
 import Calc.Ability.Error
 import Calc.ExprUtils
 import Calc.Types.Ability
 import Calc.Types.Expr
 import Calc.Types.Function
+import Calc.Types.Identifier
 import Calc.Types.Import
 import Calc.Types.Module
 import Calc.Types.ModuleAnnotations
@@ -162,7 +162,7 @@ abilityExpr (EConstructor ann constructor as) = do
   EConstructor ann constructor <$> traverse abilityExpr as
 abilityExpr (EApply ann fn@(EVar _ (Identifier fnVar)) args) = do
   let functionName = FunctionName fnVar
-  isImport <- asks (S.member functionName  . aeImportNames)
+  isImport <- asks (S.member functionName . aeImportNames)
   if isImport
     then tell (S.singleton $ CallImportedFunction ann functionName)
     else do

wasm-calc12/src/Calc/Linearity/Decorate.hs

@@ -13,11 +13,10 @@ import Calc.ExprUtils
 import Calc.Linearity.Types
 import Calc.TypeUtils
 import Calc.Types.Expr
-import Calc.Types.FunctionName
 import Calc.Types.Identifier
 import Calc.Types.Pattern
 import Calc.Types.Type
-import Control.Monad (unless, when)
+import Control.Monad (unless)
 import Control.Monad.State
 import Control.Monad.Writer
 import Data.Bifunctor (second)
@@ -265,13 +264,8 @@ decorate (EIf ty predExpr thenExpr elseExpr) = do
     <$> decorate predExpr
     <*> pure (mapOuterExprAnnotation (second (const uniqueToElse)) decoratedThen)
     <*> pure (mapOuterExprAnnotation (second (const uniqueToThen)) decoratedElse)
-decorate (EApply ty fnName@(FunctionName inner) args) = do
-  -- if we know about the var, assume it's a lambda not a built in function
-  let identifier = Identifier inner
-  isVar <- gets (M.member (UserDefined identifier) . lsVars)
-  when isVar $
-    recordUse (Identifier inner) ty
-  EApply (ty, Nothing) fnName <$> traverse decorate args
+decorate (EApply ty fn args) = do
+  EApply (ty, Nothing) <$> decorate fn <*> traverse decorate args
 decorate (ETuple ty a as) =
   ETuple (ty, Nothing) <$> decorate a <*> traverse decorate as
 decorate (EBox ty a) =

wasm-calc12/src/Calc/Parser/Expr.hs

@@ -166,16 +166,15 @@ applyParser :: Parser (Expr Annotation)
 applyParser = addLocation $ do
   func <- applyFuncParser
   let argParser = do
-          stringLiteral "("
-          args <- sepEndBy exprParserInternal (stringLiteral ",")
-          stringLiteral ")"
-          pure args
+        stringLiteral "("
+        args <- sepEndBy exprParserInternal (stringLiteral ",")
+        stringLiteral ")"
+        pure args
   let argParser' :: Parser [[ParserExpr]]
       argParser' = (: []) <$> argParser
   args <- chainl1 argParser' (pure (<>))
   pure $ foldl (EApply mempty) func args
 
-
 tupleParser :: Parser (Expr Annotation)
 tupleParser = label "tuple" $
   addLocation $ do

wasm-calc12/src/Calc/Parser/Shared.hs

@@ -1,7 +1,8 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Calc.Parser.Shared
-  ( chainl1,inBrackets,
+  ( chainl1,
+    inBrackets,
     myLexeme,
     withLocation,
     stringLiteral,
@@ -60,7 +61,6 @@ maybePred parser predicate' = try $ do
     Just b -> pure b
     _ -> fail $ T.unpack $ "Predicate did not hold for " <> T.pack (show a)
 
-
 -- | stolen from Parsec, allows parsing infix expressions without recursion
 -- death
 chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
@@ -72,4 +72,3 @@ chainl1 p op = do x <- p; rest x
         y <- p
         rest (f x y)
         <|> return x
-

wasm-calc12/src/Calc/Typecheck/Elaborate.hs

@@ -7,7 +7,6 @@ module Calc.Typecheck.Elaborate
   )
 where
 
-import qualified Data.Map.Strict as M
 import Calc.ExprUtils
 import Calc.Typecheck.Error
 import Calc.Typecheck.Helpers
@@ -25,6 +24,7 @@ import Calc.Types.Test
 import Calc.Types.Type
 import Control.Monad.State
 import Data.Functor
+import qualified Data.Map.Strict as M
 import qualified Data.Set as S
 
 elaborateModule ::
@@ -53,14 +53,20 @@ elaborateModule
             }
 
     -- statically provide types of all functions in scope
-    let functionsInScope = foldMap (\(Function {fnFunctionName,fnAnn,fnArgs,fnReturnType}) ->
-
-          M.singleton fnFunctionName (
-
-                     TFunction fnAnn (faType <$> fnArgs) fnReturnType
-
-                                     )) mdFunctions
-
+    let functionsInScope =
+          foldMap
+            ( \(Function {fnFunctionName, fnAnn, fnArgs, fnReturnType}) ->
+                M.singleton
+                  fnFunctionName
+                  ( TFunction fnAnn (faType <$> fnArgs) fnReturnType
+                  )
+            )
+            mdFunctions
+
+    let importsInScope =
+          foldMap
+            (\(Import {impImportName, impAnn, impArgs, impReturnType}) -> M.singleton impImportName (TFunction impAnn (iaType <$> impArgs) impReturnType))
+            mdImports
 
     runTypecheckM typecheckEnv $ do
       globals <-
@@ -84,7 +90,7 @@ elaborateModule
       functions <-
         traverse
           ( \fn -> do
-              elabFn <- elaborateFunction functionsInScope fn
+              elabFn <- elaborateFunction (functionsInScope <> importsInScope) fn
               storeFunction
                 (fnFunctionName elabFn)
                 (S.fromList $ fnGenerics fn)
@@ -187,7 +193,8 @@ elaborateFunction ::
   M.Map FunctionName (Type ann) ->
   Function ann ->
   TypecheckM ann (Function (Type ann))
-elaborateFunction functionsInScope
+elaborateFunction
+  functionsInScope
   ( Function
       { fnPublic,
         fnAnn,
@@ -201,7 +208,7 @@ elaborateFunction functionsInScope
     ) = do
     -- include current function with arguments so we can recursively call ourselves
     let tyCurrentFunction =
-                        TFunction fnAnn (faType <$> fnArgs) fnReturnType
+          TFunction fnAnn (faType <$> fnArgs) fnReturnType
 
     exprA <-
       withFunctionEnv

wasm-calc12/src/Calc/Typecheck/Helpers.hs

@@ -196,8 +196,10 @@ withFunctionEnv args functionsInScope generics =
    in local
         ( \tce ->
             tce
-              { tceVars = tceVars tce <> HM.fromList identifiersFromFunctions <>
-                  HM.fromList identifiersFromArgs,
+              { tceVars =
+                  tceVars tce
+                    <> HM.fromList identifiersFromFunctions
+                    <> HM.fromList identifiersFromArgs,
                 tceGenerics = generics
               }
         )

wasm-calc12/src/Calc/Typecheck/Infer.hs

@@ -283,11 +283,11 @@ checkReturnType (TUnificationVar {}) p@(TPrim ann _) =
 checkReturnType _ ty = pure ty
 
 freeVars :: Type ann -> S.Set TypeVar
-freeVars ty
-  = go ty
-    where
-      go (TVar _ var) = S.singleton var
-      go other = monoidType go other
+freeVars ty =
+  go ty
+  where
+    go (TVar _ var) = S.singleton var
+    go other = monoidType go other
 
 checkApply ::
   Maybe (Type ann) ->

wasm-calc12/src/Calc/Wasm/FromExpr/Expr.hs

@@ -9,13 +9,13 @@ import Calc.Types
 import Calc.Wasm.FromExpr.Drops
   ( addDropsFromPath,
     addDropsToWasmExpr,
-    --dropFunctionForType,
+    dropFunctionForType,
   )
 import Calc.Wasm.FromExpr.Helpers
 import Calc.Wasm.FromExpr.Patterns
 import Calc.Wasm.FromExpr.Types
 import Calc.Wasm.ToWasm.Types
--- import Control.Monad (void)
+import Control.Monad (void)
 import Control.Monad.Except
 import Control.Monad.State
 import qualified Data.List.NonEmpty as NE
@@ -181,7 +181,7 @@ fromExprWithDrops expr = do
 
   addDropsToWasmExpr drops wasmExpr
 
-fromFunctionApply ::
+_fromFunctionApply ::
   ( MonadState FromExprState m,
     MonadError FromWasmError m,
     Show ann,
@@ -190,7 +190,7 @@ fromFunctionApply ::
   FunctionName ->
   [Expr (Type ann, Maybe (Drops ann))] ->
   m WasmExpr
-fromFunctionApply funcName args = do
+_fromFunctionApply funcName args = do
   (fIndex, fGenerics, fArgTypes) <- lookupFunction funcName
   let types =
         monomorphiseTypes
@@ -201,6 +201,7 @@ fromFunctionApply funcName args = do
   wasmArgs <- traverse fromExpr args
   pure $ WApply fIndex (wasmArgs <> dropArgs)
 
+{-
 fromLambdaApply ::
   ( MonadState FromExprState m,
     MonadError FromWasmError m,
@@ -216,6 +217,7 @@ fromLambdaApply (FunctionName inner) args = do
   wasmArgs <- traverse fromExpr args
 
   pure $ WApplyIndirect (WVar fIndex) wasmArgs
+-}
 
 fromExpr ::
   ( MonadError FromWasmError m,
@@ -306,17 +308,17 @@ fromExpr (EVar _ ident) = do
     `catchError` \_ -> WGlobal <$> lookupGlobal ident
 fromExpr (EApply _ fnExpr _args) = do
   error ("fromExpr " <> show fnExpr)
-  {-
-  (fIndex, fGenerics, fArgTypes) <- lookupFunction funcName
-  let types =
-        monomorphiseTypes
-          fGenerics
-          fArgTypes
-          (void . fst . getOuterAnnotation <$> args)
-  dropArgs <- traverse (dropFunctionForType . snd) types
-  wasmArgs <- traverse fromExpr args
-  pure $ WApply fIndex (wasmArgs <> dropArgs)
-  -}
+{-
+(fIndex, fGenerics, fArgTypes) <- lookupFunction funcName
+let types =
+      monomorphiseTypes
+        fGenerics
+        fArgTypes
+        (void . fst . getOuterAnnotation <$> args)
+dropArgs <- traverse (dropFunctionForType . snd) types
+wasmArgs <- traverse fromExpr args
+pure $ WApply fIndex (wasmArgs <> dropArgs)
+-}
 fromExpr (ETuple (ty, _) a as) = do
   wasmType <- liftEither $ scalarFromType ty
   index <- addLocal Nothing wasmType

wasm-calc12/test/Test/Typecheck/TypecheckSpec.hs

@@ -28,7 +28,7 @@ testInputs =
 
 spec :: Spec
 spec = do
-  fdescribe "TypecheckSpec" $ do
+  describe "TypecheckSpec" $ do
     describe "Function" $ do
       let succeeding =
             [ ("function one () -> Int64 { 1 }", TFunction () [] tyInt64),