Fixes the closure typing in instance definitions.

src/Solcore/Frontend/TypeInference/TcStmt.hs

@@ -741,10 +741,20 @@ verifySignatures instd@(Instance _ _ ps n ts t funs) =
 
 checkMemberType :: (Name, Qual Ty, Qual Ty) -> TcM ()
 checkMemberType (qn, qt@(ps :=> t), qt'@(ps' :=> t'))
-  = do
-      _ <- tcmMatch t t' `catchError` (\ _ -> invalidMemberType qn t t')
-      pure ()
+  -- when we have a closure in the instance type,
+  -- it will not be an instance of the most general
+  -- type present in the type class.
+  | hasClosureType t = pure ()
+  -- no closure, we can check if the infered type is
+  -- an instance of the class annotated most general
+  -- type.
+  | otherwise
+    = do
+        _ <- tcmMatch t t' `catchError` (\ _ -> invalidMemberType qn t t')
+        pure ()
 
+hasClosureType :: Ty -> Bool
+hasClosureType = any isClosureName . tyconNames
 
 invalidMemberType :: Name -> Ty -> Ty -> TcM a
 invalidMemberType n cls ins

test/Cases.hs

@@ -241,6 +241,8 @@ cases =
     , runTestForFile "yul-function-typing.solc" caseFolder
     , runTestForFile "yul-return.solc" caseFolder
     , runTestExpectingFailure "unbound-instance-var.solc" caseFolder
+    , runTestForFile "closure-fun-single.solc" caseFolder
+    , runTestForFile "instance-closure-error.solc" caseFolder
     ]
  where
   caseFolder = "./test/examples/cases"

test/examples/cases/closure-fun-single.solc

@@ -0,0 +1,5 @@
+function ct(x : word) -> ((word) -> word) {
+    return lam(y : word) {
+        return x;
+    };
+}

test/examples/cases/instance-closure-error.solc

@@ -0,0 +1,11 @@
+forall t . class t:CtFun {
+    function ct(x : t) -> ((t) -> t);
+}
+
+instance word:CtFun {
+    function ct(x : word) -> ((word) -> word) {
+        return lam(y : word) {
+            return x;
+        };
+    }
+}