bugfix in the handling of implicit arguments in the typechecker

src/runtime/haskell/PGF/TypeCheck.hs

@@ -351,6 +351,7 @@ tcExpr scope (EMeta _) tty = do
   return (EMeta i)
 tcExpr scope e0        tty = do
   (e0,tty0) <- infExpr scope e0
+  (e0,tty0) <- appImplArg scope e0 tty0
   i <- newGuardedMeta e0
   eqType scope (scopeSize scope) i tty tty0
   return (EMeta i)
@@ -424,6 +425,14 @@ tcArg scope e1 e2 delta ty0@(DTyp ((Implicit,x,ty):hs) c es) = do
     then tcArg scope (EApp e1 (EImplArg (EMeta i))) e2                                delta  (DTyp hs c es)
     else tcArg scope (EApp e1 (EImplArg (EMeta i))) e2 (VMeta i (scopeEnv scope) [] : delta) (DTyp hs c es)
 
+appImplArg scope e (TTyp delta (DTyp ((Implicit,x,ty1):hypos) cat es)) = do
+  i <- newMeta scope (TTyp delta ty1)
+  let delta' = if x == wildCId
+                 then                               delta  
+                 else VMeta i (scopeEnv scope) [] : delta
+  appImplArg scope (EApp e (EImplArg (EMeta i))) (TTyp delta' (DTyp hypos cat es))
+appImplArg scope e tty                                                 = return (e,tty)
+
 -----------------------------------------------------
 -- eqType
 -----------------------------------------------------

testsuite/runtime/typecheck/Graph.gf

@@ -16,4 +16,6 @@ fun
   
   link : ({n,m} : Node) -> Link n m -> Path n m ;
   join : ({n,p,m} : Node) -> Link n p -> Path p m -> Path n m ;
+  
+  id : ({n} : Node) -> Link n n ;
 }

testsuite/runtime/typecheck/hard-unification.gfs

@@ -1,3 +1,3 @@
-i testsuite/runtime/typecheck/Hard.gf
+i -src testsuite/runtime/typecheck/Hard.gf
 ai s ? (app ?) ex
 ai s ? (app ?) ?

testsuite/runtime/typecheck/hard-unification.gfs.gold

@@ -1,5 +1,6 @@
-Expression: s (\v0 -> v0) (app (\v0 -> v0)) ex
+Expression:  s (\v0 -> v0) (app (\v0 -> v0)) ex
-Type:       S
+Type:        S
+Probability: 1.0
 
 Meta variable(s) ?2 should be resolved
 in the expression: s ?2 (app ?2) ?4

testsuite/runtime/typecheck/implicit-arguments.gfs

@@ -7,3 +7,4 @@ ai <? : Link {n1} {n2}>
 ai <\x -> x : ({m},n : Node) -> Node>
 ai <n1 : ({m} : Node) -> Node>
 ai <? : ({m} : Node) -> Node>
+ai <link id : Path n1 n1>

testsuite/runtime/typecheck/implicit-arguments.gfs.gold

@@ -1,22 +1,33 @@
-Expression: join {n1} {n2} {n3} l12 (link {n2} {n3} l23)
+Expression:  join {n1} {n2} {n3} l12 (link {n2} {n3} l23)
-Type:       Path n1 n3
+Type:        Path n1 n3
+Probability: 1.0000000000000002e-2
 
-Expression: join {n1} {n2} {n3} l12 (link {n2} {n3} l23)
+Expression:  join {n1} {n2} {n3} l12 (link {n2} {n3} l23)
-Type:       Path n1 n3
+Type:        Path n1 n3
+Probability: 1.0000000000000002e-2
 
-Expression: <?2 : Label {?1}>
+Expression:  <?2 : Label {?1}>
-Type:       Label {?1}
+Type:        Label {?1}
+Probability: 1.0
 
-Expression: <?2 : Label {n1}>
+Expression:  <?2 : Label {n1}>
-Type:       Label {n1}
+Type:        Label {n1}
+Probability: 1.0
 
 {n1} is implicit argument but not implicit argument is expected here
-Expression: <\{_1}, x -> x : ({m} : Node) -> (n : Node) -> Node>
+Expression:  <\{_1}, x -> x : ({m} : Node) -> (n : Node) -> Node>
-Type:       ({m} : Node) -> (n : Node) -> Node
+Type:        ({m} : Node) -> (n : Node) -> Node
+Probability: 1.0
 
-Expression: <\{_1} -> n1 : ({m} : Node) -> Node>
+Expression:  <\{_1} -> n1 : ({m} : Node) -> Node>
-Type:       ({m} : Node) -> Node
+Type:        ({m} : Node) -> Node
+Probability: 1.0
 
-Expression: <\{_1} -> ?1 : ({m} : Node) -> Node>
+Expression:  <\{_1} -> ?1 : ({m} : Node) -> Node>
-Type:       ({m} : Node) -> Node
+Type:        ({m} : Node) -> Node
+Probability: 1.0
+
+Expression:  <link {n1} {n1} (id {n1}) : Path n1 n1>
+Type:        Path n1 n1
+Probability: 1.0
 

testsuite/runtime/typecheck/typecheck.gfs.gold

@@ -12,39 +12,48 @@ unknown category of function identifier unknown_fun
 Category unknown_cat is not in scope
 Cannot infer the type of expression \x -> x
 A function type is expected for the expression \x -> x instead of type Int
-Expression: append (succ (succ zero)) (succ zero) (vector (succ (succ zero))) (vector (succ zero))
+Expression:  append (succ (succ zero)) (succ zero) (vector (succ (succ zero))) (vector (succ zero))
-Type:       Vector (succ (succ (succ zero)))
+Type:        Vector (succ (succ (succ zero)))
+Probability: 3.532127097800926e-8
 
-Expression: <\m, n -> vector (plus m n) : (m : Nat) -> (n : Nat) -> Vector (plus m n)>
+Expression:  <\m, n -> vector (plus m n) : (m : Nat) -> (n : Nat) -> Vector (plus m n)>
-Type:       (m : Nat) -> (n : Nat) -> Vector (plus m n)
+Type:        (m : Nat) -> (n : Nat) -> Vector (plus m n)
+Probability: 1.0
 
-Expression: mkMorph (\x -> succ zero)
+Expression:  mkMorph (\x -> succ zero)
-Type:       Morph (\v0 -> succ zero)
+Type:        Morph (\v0 -> succ zero)
+Probability: 0.5
 
-Expression: idMorph (mkMorph (\x -> x))
+Expression:  idMorph (mkMorph (\x -> x))
-Type:       Nat
+Type:        Nat
+Probability: 0.125
 
 Couldn't match expected type Morph (\v0 -> v0)
        against inferred type Morph (\v0 -> succ zero)
 In the expression: mkMorph (\x -> succ zero)
-Expression: <append zero (succ zero) : Vector zero -> Vector (succ zero) -> Vector (succ zero)>
+Expression:  <append zero (succ zero) : Vector zero -> Vector (succ zero) -> Vector (succ zero)>
-Type:       Vector zero -> Vector (succ zero) -> Vector (succ zero)
+Type:        Vector zero -> Vector (succ zero) -> Vector (succ zero)
+Probability: 1.0
 
-Expression: <\n, v1, n1, v2 -> append n n1 v1 v2 : (n : Nat) -> Vector n -> (m : Nat) -> Vector m -> Vector (plus n m)>
+Expression:  <\n, v1, n1, v2 -> append n n1 v1 v2 : (n : Nat) -> Vector n -> (m : Nat) -> Vector m -> Vector (plus n m)>
-Type:       (n : Nat) -> Vector n -> (m : Nat) -> Vector m -> Vector (plus n m)
+Type:        (n : Nat) -> Vector n -> (m : Nat) -> Vector m -> Vector (plus n m)
+Probability: 1.0
 
 Category EQ is not in scope
-Expression: <\v1, v2 -> cmpVector ?7 v1 v2 : Vector ?7 -> Vector ?7 -> Int> (vector ?7)
+Expression:  <\v1, v2 -> cmpVector ?7 v1 v2 : Vector ?7 -> Vector ?7 -> Int> (vector ?7)
-Type:       Vector ?7 -> Int
+Type:        Vector ?7 -> Int
+Probability: 0.3333333333333333
 
 Couldn't match expected type (m : Nat) -> Vector ?1
        against inferred type (n : Nat) -> Vector n
 In the expression: vector
-Expression: f1 (\v -> v) vector
+Expression:  f1 (\v -> v) vector
-Type:       Int
+Type:        Int
+Probability: 5.555555555555555e-2
 
-Expression: f1 (\v -> succ v) (\x -> vector (succ x))
+Expression:  f1 (\v -> succ v) (\x -> vector (succ x))
-Type:       Int
+Type:        Int
+Probability: 0.16666666666666666
 
 Couldn't match expected type Vector x
        against inferred type Vector (succ x)
@@ -52,22 +61,25 @@ In the expression: vector (succ x)
 Couldn't match expected type Vector n
        against inferred type Vector (succ n)
 In the expression: vector (succ n)
-Expression: h ?2 (u0 ?2)
+Expression:  h ?2 (u0 ?2)
-Type:       Int
+Type:        Int
+Probability: 8.333333333333333e-2
 
 Couldn't match expected type U ?2 ?2
        against inferred type U ?2 (succ ?2)
 In the expression: u1 ?2
 Meta variable(s) ?11 should be resolved
 in the expression: cmpVector (succ (succ zero)) (vector (succ (succ zero))) (append ?11 (succ zero) (vector ?11) (vector (succ zero)))
-Expression: diff (succ (succ (succ zero))) (succ (succ zero)) (vector (succ (succ (succ (succ (succ zero)))))) (vector (succ (succ (succ zero))))
+Expression:  diff (succ (succ (succ zero))) (succ (succ zero)) (vector (succ (succ (succ (succ (succ zero)))))) (vector (succ (succ (succ zero))))
-Type:       Vector (succ (succ zero))
+Type:        Vector (succ (succ zero))
+Probability: 2.1558392930913853e-12
 
 Couldn't match expected type Vector (plus (succ (succ (succ zero))) (succ (succ zero)))
        against inferred type Vector (succ (succ (succ (succ zero))))
 In the expression: vector (succ (succ (succ (succ zero))))
-Expression: idMorph (mkMorph2 (\x -> x) (vector zero))
+Expression:  idMorph (mkMorph2 (\x -> x) (vector zero))
-Type:       Nat
+Type:        Nat
+Probability: 1.0416666666666666e-2
 
 Couldn't match expected type Vector zero
        against inferred type Vector n