Coverage report: home:Documents;Work;Repo;alu;src;intermediate;spec.lisp.newest
| Expressions | Branches | Code Forms | Functions |
| Total | Entered | % entered | Fully covered | % fully covered | total unreached | Total | Covered | % covered | Total | Fully covered | % fully covered | Partly covered | % partly covered | Not entered | % not entered |
| | | | | | | | | | | | | | | |
Key
Fully covered - every single instruction executed
Partly covered - entered but some subforms not executed
Never entered - not a single instruction executed
Uninstrumented - a form whose coverage was not measured
1 (in-package :alu.ir.spec)
2
3 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4 ;; IR Variants through the pipeline
5 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6
7 ;; The Pipeline for how these types get used is roughly as follows.
8 ;;
9 ;; +-----------------------------------+
10 ;; | Linear-Term |
11 ;; +-----------------------------------+
12 ;; | Alu Term through ANF |
13 ;; | |
14 ;; | Binders contain term-type-manip… |
15 ;; | |
16 ;; | No other changes |
17 ;; | |
18 ;; +-----------------------------------+
19 ;; |
20 ;; |
21 ;; v
22 ;; +-----------------------------------+
23 ;; | Type Aware Term |
24 ;; +-----------------------------------+
25 ;; | Term through removal of top level |
26 ;; | normal form |
27 ;; | |
28 ;; | Binders contain term-type-manip… |
29 ;; | |
30 ;; | |
31 ;; | We run algorithms like |
32 ;; | - type checking |
33 ;; | - Expansion |
34 ;; | - ETC |
35 ;; +-----------------------------------+
36 ;; |
37 ;; |
38 ;; v
39 ;; +-----------------------------------+
40 ;; | Expanded-Term |
41 ;; +-----------------------------------+
42 ;; | Term through removal of top level |
43 ;; | normal forms |
44 ;; | |
45 ;; | Binders contain term-no-binders |
46 ;; | |
47 ;; | |
48 ;; | We run algorithms like |
49 ;; | - type checking |
50 ;; | - Expansion |
51 ;; | - ETC |
52 ;; +-----------------------------------+
53 ;; |
54 ;; |
55 ;; v
56 ;; +-----------------------------------+
57 ;; | Fully-Expanded-Term |
58 ;; +-----------------------------------+
59 ;; | Term where concepts like |
60 ;; | Arrays and records are |
61 ;; | expanded out. |
62 ;; | |
63 ;; | Binders contain spc:base |
64 ;; | |
65 ;; | We run algorithms like |
66 ;; | - void removal |
67 ;; | - extra let removal |
68 ;; | - ETC |
69 ;; +-----------------------------------+
70 ;;
71
72 (deftype linear-term ()
73 "A Linear term is a term with no nested terms and is in proper ANF form."
74 `(or spc:term-type-manipulation
75 (starting-binders spc:term-type-manipulation)
76 terms:standalone-ret))
Show expansion
Show tags
(lambda (#:whole54555 #:environment54556)
(let* ((#:args54557 (funcall 'ccl::prepare-to-destructure (cdr #:whole54555) nil 0 0)))
'(or spc:term-type-manipulation (starting-binders spc:term-type-manipulation) terms:standalone-ret)))
77
78 (deftype type-aware-term ()
79 "An expanded term is a term where all top level forms have been
80 expanded into lets or returns"
81 `(or (starting-binders spc:term-type-manipulation)
82 terms:standalone-ret))
Show expansion
Show tags
(lambda (#:whole54573 #:environment54574)
(let* ((#:args54575 (funcall 'ccl::prepare-to-destructure (cdr #:whole54573) nil 0 0)))
'(or (starting-binders spc:term-type-manipulation) terms:standalone-ret)))
83
84 (deftype expanded-term ()
85 "An expanded term is a term where all top level forms have been
86 expanded into lets or returns, and type coercions have been removed"
87 `(or (starting-binders spc:term-no-binding)
88 terms:standalone-ret))
Show expansion
Show tags
(lambda (#:whole54591 #:environment54592)
(let* ((#:args54593 (funcall 'ccl::prepare-to-destructure (cdr #:whole54591) nil 0 0)))
'(or (starting-binders spc:term-no-binding) terms:standalone-ret)))
89
90 (deftype fully-expanded-term ()
91 "A fully expanded term is a `expanded-term' with the records part
92 removed. Or as we can view it a base term, with the binders added in."
93 `(or (binders spc:base)
94 terms:standalone-ret))
Show expansion
Show tags
(lambda (#:whole54609 #:environment54610)
(let* ((#:args54611 (funcall 'ccl::prepare-to-destructure (cdr #:whole54609) nil 0 0)))
'(or (binders spc:base) terms:standalone-ret)))
95
96 (deftype starting-binders (&optional contains)
97 "Terms which deal with binding and naming, the input argument
98 represents what data may be in the value of the binders."
99 (declare (ignore contains))
100 `(or terms:bind
101 spc:bind-constraint))
Show expansion
Show tags
(lambda (#:whole54627 #:environment54628)
(let* ((#:args54629 (funcall 'ccl::prepare-to-destructure (cdr #:whole54627) '(&optional contains) 0 1))
(contains
(if #:args54629
(prog1 (ccl::%car #:args54629) (setq #:args54629 (ccl::%cdr (ccl::typed-form 'list #:args54629))))
'*)))
'(or terms:bind spc:bind-constraint)))
102
103 (deftype binders (&optional contains)
104 "Terms which deal with binding and naming, the input argument
105 represents what data may be in the value of the binders."
106 `(or (starting-binders ,contains)
107 terms:multiple-bind))
Show expansion
Show tags
(lambda (#:whole54645 #:environment54646)
(let* ((#:args54647 (funcall 'ccl::prepare-to-destructure (cdr #:whole54645) '(&optional contains) 0 1))
(contains
(if #:args54647
(prog1 (ccl::%car #:args54647) (setq #:args54647 (ccl::%cdr (ccl::typed-form 'list #:args54647))))
'*)))
(list* 'or (list 'starting-binders contains) '(terms:multiple-bind))))
108
109 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
110 ;; Linearized types List Aliases
111 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
112
113 (deftype constraint-list ()
114 "A constraint-list is a list of linear-terms"
115 `(satisfies linear-list))
Show expansion
Show tags
(lambda (#:whole54663 #:environment54664)
(let* ((#:args54665 (funcall 'ccl::prepare-to-destructure (cdr #:whole54663) nil 0 0))) '(satisfies linear-list)))
116
117 (deftype type-aware-list ()
118 `(satisfies type-aware-list))
Show expansion
Show tags
(lambda (#:whole54681 #:environment54682)
(let* ((#:args54683 (funcall 'ccl::prepare-to-destructure (cdr #:whole54681) nil 0 0))) '(satisfies type-aware-list)))
119
120 (deftype expanded-list ()
121 "A constraint-list is a list of expanded-terms"
122 `(satisfies expanded-list))
Show expansion
Show tags
(lambda (#:whole54699 #:environment54700)
(let* ((#:args54701 (funcall 'ccl::prepare-to-destructure (cdr #:whole54699) nil 0 0))) '(satisfies expanded-list)))
123
124 (deftype fully-expanded-list ()
125 "A constraint-list is a list of fully-expanded-terms"
126 `(satisfies fully-expanded-list))
Show expansion
Show tags
(lambda (#:whole54717 #:environment54718)
(let* ((#:args54719 (funcall 'ccl::prepare-to-destructure (cdr #:whole54717) nil 0 0)))
'(satisfies fully-expanded-list)))
127
128 (defun linear-list (list)
129 (and (listp list)
130 (every (lambda (x) (typep x 'linear-term)) list)))
Show expansion
Show tags
(lambda (list)
(if (eq (ccl::lisptag list) 3)
(let ((#:g54735
(function (lambda (x)
(let* ((#:g54737 x))
(or (funcall 'numberp #:g54737)
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x3020036935AF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200369070F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200368D86F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200368A9CF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x302003687B2F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x302003684C8F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x302003681DEF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200367EF4F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200367C0AF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200367920F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200367636F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x3020036734CF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54737
'(#:load-time-eval (funcall #<Anonymous Function #x30200367062F>))))))))
(#:g54736 list))
(funcall 'ccl::some-xx-one 2 t #:g54735 #:g54736))
nil))
131
132 (defun type-aware-list (list)
133 (and (listp list)
134 (every (lambda (x) (typep x 'type-aware-term)) list)))
Show expansion
Show tags
(lambda (list)
(if (eq (ccl::lisptag list) 3)
(let ((#:g54783
(function (lambda (x)
(let* ((#:g54785 x))
(or (funcall 'ccl::std-instance-class-cell-typep
#:g54785
'(#:load-time-eval (funcall #<Anonymous Function #x3020036C880F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54785
'(#:load-time-eval (funcall #<Anonymous Function #x3020036C596F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54785
'(#:load-time-eval (funcall #<Anonymous Function #x3020036C2ACF>))))))))
(#:g54784 list))
(funcall 'ccl::some-xx-one 2 t #:g54783 #:g54784))
nil))
135
136 (defun expanded-list (list)
137 (and (listp list)
138 (every (lambda (x) (typep x 'expanded-term)) list)))
Show expansion
Show tags
(lambda (list)
(if (eq (ccl::lisptag list) 3)
(let ((#:g54801
(function (lambda (x)
(let* ((#:g54803 x))
(or (funcall 'ccl::std-instance-class-cell-typep
#:g54803
'(#:load-time-eval (funcall #<Anonymous Function #x3020036E24BF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54803
'(#:load-time-eval (funcall #<Anonymous Function #x30200371F5FF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54803
'(#:load-time-eval (funcall #<Anonymous Function #x30200371C75F>))))))))
(#:g54802 list))
(funcall 'ccl::some-xx-one 2 t #:g54801 #:g54802))
nil))
139
140 (defun fully-expanded-list (list)
141 (and (listp list)
142 (every (lambda (x) (typep x 'fully-expanded-term)) list)))
Show expansion
Show tags
(lambda (list)
(if (eq (ccl::lisptag list) 3)
(let ((#:g54819
(function (lambda (x)
(let* ((#:g54821 x))
(or (funcall 'ccl::std-instance-class-cell-typep
#:g54821
'(#:load-time-eval (funcall #<Anonymous Function #x30200373BF7F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54821
'(#:load-time-eval (funcall #<Anonymous Function #x3020037390DF>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54821
'(#:load-time-eval (funcall #<Anonymous Function #x30200373623F>)))
(funcall 'ccl::std-instance-class-cell-typep
#:g54821
'(#:load-time-eval (funcall #<Anonymous Function #x30200373339F>))))))))
(#:g54820 list))
(funcall 'ccl::some-xx-one 2 t #:g54819 #:g54820))
nil))