X-Git-Url: https://git.lukelau.me/?p=scheme.git;a=blobdiff_plain;f=ast.scm;h=cfd774a2202cd5af24ae71c7facfd81bd966d63c;hp=86d522560a8012546e6a754499b1216052d8ce70;hb=HEAD;hpb=2d4831a551afbeec0680fa65c6d301853c8a975b

diff --git a/ast.scm b/ast.scm
index 86d5225..cfd774a 100644
--- a/ast.scm
+++ b/ast.scm
@@ -25,7 +25,6 @@
    ((builtin? x) 'builtin)
    ((symbol? x) 'var)
    ((integer? x) 'int-literal)
-   ((boolean? x) 'bool-literal)
    ((string? x) 'string-literal)))
 
 (define (ast-traverse f x)
@@ -36,7 +35,7 @@
     ('app (map f x))
     ('lambda `(lambda ,(lambda-args x) ,(f (lambda-body x))))
     ('if `(if ,@(map f (cdr x))))
-    ('case `(case ,(f (case-expr x))
+    ('case `(case ,(f (case-switch x))
 	      ,@(map (lambda (x)
 		       (list (car x) (f (cadr x))))
 		     (case-cases x))))
@@ -56,7 +55,7 @@
     ['if (append (f x)
 		 (flat-map inner (cdr x)))]
     ['case (append (f x)
-		   (inner (case-expr x))
+		   (inner (case-switch x))
 		   (flat-map inner (map cadr (case-cases x))))]
     ['stack (append (f x)
 		    (inner (caddr x)))]
@@ -64,33 +63,95 @@
 
 (define (ast-find p x)
   (define (inner y) (ast-find p y))
-  (define (any p x) (fold-left
-		     (lambda (acc y) (if acc #t (p y)))
-		     #f
-		     x))
-  (define (either . fs)
-    (if (null? fs) #f
-	(if (car fs) (car fs)
-	    (apply either (cdr fs)))))
   
   (case (ast-type x)
-    ['let (either (p x)
+    ['let (or (p x)
 	      (any inner (let-bindings x))
 	      (any inner (let-body x)))]
-    ['app (either (p x)
+    ['app (or (p x)
 	      (any inner x))]
-    ['lambda (either (p x)
+    ['lambda (or (p x)
 		 (inner (lambda-body x)))]
-    ['if (either (p x) (any inner (cdr x)))]
-    ['stack (either (p x) (inner (caddr x)))]
+    ['if (or (p x) (any inner (cdr x)))]
+    ['case (or (p x)
+	       (any inner (map cadr (case-cases x)))
+	       (inner (case-switch x)))]
+    ['stack (or (p x) (inner (caddr x)))]
     [else (p x)]))
 
 (define let-bindings cadr)
 (define let-body cddr)
 
-(define case-expr cadr)
+(define case-switch cadr)
 (define case-cases cddr)
 
+(define (constructor? data-layouts x)
+  (and (eqv? (ast-type x) 'var)
+       (assoc x (flat-map cdr data-layouts))))
+
+(define (all-cases data-layouts type)
+  (let ([sums (assoc type data-layouts)])
+    (if sums
+	(flat-map (lambda (sum)
+		    (let* ([sum-name (car sum)]
+			   [products (cdr sum)]
+			   [product-cases (map (lambda (y) (all-cases data-layouts y)) products)])
+		      (if (null? product-cases)
+			  (list sum-name) ; singletons aren't enclosed in a list [(foo x) 42] vs [foo 42]
+			  (apply combinations (cons (list sum-name) product-cases)))))
+		  (cdr sums))
+	'(:binding))))
+
+					; does a cover b
+(define (case-covers? data-layouts a b)
+  (let ([a-binding? (and (eqv? (ast-type a) 'var) (not (constructor? data-layouts a)))])
+    (cond
+     [(eqv? ':binding b) a-binding?]
+     [a-binding? #t]
+					; a literal/singleton
+     [(eqv? (ast-type b) 'var) (eqv? b a)]
+					; two different constructors
+     [(not (eqv? (car a) (car b))) #f]
+					; two same constructors
+     [else
+      (all (map (lambda (p q)
+		  (case-covers? data-layouts p q))
+		(cdr a) (cdr b)))])))
+
+(define (verify-cases data-layouts annotated-program)
+
+  ;; (define (check-pattern switch-type pat)
+
+  ;;   (define (impossible-match)
+  ;;     (error "Can't pattern match ~a with ~a" switch-type (ann-expr pat)))
+
+  ;;   (if (assoc switch-type data-layouts)
+  ;; 	(begin
+  ;; 	  (let ([sums (cdr (assoc switch-type data-layouts))])
+  ;; 	    (unless (eqv? (ast-type (ann-expr pat)) 'var) (impossible-match))
+  ;; 	    (unless (assoc (car (ann-expr pat)) sums) (impossible-match))
+  ;; 	    (unless 
+  ;; 	  )
+  ;;      (begin
+  ;; 	 (unless (assoc switch-type allowed-match-ast-types)
+  ;; 	   (error #f "Can't pattern match on ~a" switch-type))
+	 
+  ;; 	 (let ([allowed (cdr (assoc switch-type allowed-match-ast-types))])
+  ;; 	   (unless (assoc (ast-type (ann-expr pat)) allowed) (impossible-match)))))))
+
+  
+  (let ([expr (ann-expr annotated-program)])
+    (case (ast-type expr)
+      ['case
+	  (let* ([switch-type (ann-type (case-switch expr))]
+		 [cases (map car (case-cases expr))]
+		 [case-covered?
+		  (lambda (x) (any (lambda (y) (case-covers? data-layouts y x)) cases))])
+	    (unless (all (map case-covered? (all-cases data-layouts switch-type)))
+	      (error #f "not all cases covered")))]
+      [else (ast-traverse (lambda (x) (verify-cases data-layouts x)) expr)])))
+
+
 					; (let ([(foo a b) (foo 123 345)]) a)
 					;   |
 					;   v
@@ -98,7 +159,7 @@
                                         ;       [b (foo~1 (foo 123 345)]) a)
 (define (expand-pattern-matches program)
   (define (go x)
-    (define (pattern-match binding)
+    (define (let-pattern-match binding)
       (let ([binding-name (car binding)]
 	    [body (cadr binding)])
 	(if (eqv? (ast-type binding-name) 'var)
@@ -132,11 +193,12 @@
 			       binding)))
 	      
 	      (flat-map (lambda (y i)
-			  (pattern-match (list y `(,(destructor i) ,body))))
+			  (let-pattern-match (list y `(,(destructor i) ,body))))
 			products
 			(range 0 (length products)))))))
+
     (case (ast-type x)
-      ['let `(let ,(flat-map pattern-match (let-bindings x))
+      ['let `(let ,(flat-map let-pattern-match (let-bindings x))
 	       ,@(map go (let-body x)))]
       [else (ast-traverse go x)]))
   (program-map-exprs go program))