Adding L2 Optimization

README.md

@@ -1,7 +1,7 @@
 # Status
 
-[![.github/workflows/ci.yml](https://github.com/clause/471c/actions/workflows/ci.yml/badge.svg)](https://github.com/clause/471c/actions/workflows/ci.yml)
-[![Coverage](https://codecov.io/gh/clause/471c/branch/main/graph/badge.svg)](https://codecov.io/gh/clause/471c)
+[![.github/workflows/ci.yml](https://github.com/JTFulkerson/471c/actions/workflows/ci.yml/badge.svg)](https://github.com/JTFulkerson/471c/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/JTFulkerson/471c/branch/main/graph/badge.svg)](https://codecov.io/gh/JTFulkerson/471c)
 
 # Contributing 
 

packages/L0/README.md

@@ -0,0 +1,3 @@
+L0
+
+L0 is now a procedure based language as compared to our previous expression and statement languages. Here, a program has a sequence of named procedures each containing its own parameters and a statement body. A statement can have copy, immediate, primative, branch, allocate, load, store, address, call, and hault. The main differences are that L0 organizes code into multiple named procedures whereas L1 had a single extry program with a statement body. L1 also uses abstract and apply for its functions where L0 replaces them with address and call removing a layer of abstraction. L0 also makes procedures ex plicity and predefined rather than in others where they were constructred functions at runtime. 

packages/L1/README.md

@@ -0,0 +1,3 @@
+L1
+
+Now in L1 it is a statement based language with very explicit flow control. There exists a program which has parameters and a body, and the statements are similar to L2 and L3 with a few differences. We have copy, immediate, primative, branch, abstract, apply, allocate, load, store, and hault. The differences with L1 as compared to L2 and L3 is that L2 used nested terms as expressions while now L1 replaces all of those with sequential statements. Doing this makes flow control explicit as each statement has a then continuation, except for apply and hault. L1 also adds a copy ability to move values between identifiers, and hault to end the program. L1 removes the idea of let, reference, and begin. 

packages/L2/README.md

@@ -0,0 +1,3 @@
+L2
+
+L2 has most of the same characteristics as L3 except letrec is missing. Functions, arithmetic, branching, and heap management all remain the same but not having letrec means that recursive bindings are not avalible. 

packages/L2/src/L2/constant_folding.py

@@ -0,0 +1,180 @@
+from functools import partial
+
+from .syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
+    Immediate,
+    Let,
+    Load,
+    Primitive,
+    Reference,
+    Store,
+    Term,
+)
+from .util import (
+    Context,
+    extend_context_with_bindings,
+    recur_terms,
+)
+
+
+def _normalize_commutative_immediate_left(
+    operator: str,
+    left: Term,
+    right: Term,
+) -> Primitive:
+    return Primitive(
+        operator=operator,  # type: ignore[arg-type]
+        left=right,
+        right=left,
+    )
+
+
+def constant_folding_term(
+    term: Term,
+    context: Context,
+) -> Term:
+    recur = partial(constant_folding_term, context=context)  # noqa: F841
+
+    match term:
+        case Let(bindings=bindings, body=body):
+            new_bindings, new_context = extend_context_with_bindings(bindings, context, recur)
+            return Let(
+                bindings=new_bindings,
+                body=constant_folding_term(body, new_context),
+            )
+
+        case Reference(name=name):
+            if name in context:
+                return context[name]
+            return term
+
+        case Abstract(parameters=parameters, body=body):
+            return Abstract(parameters=parameters, body=recur(body))
+
+        case Apply(target=target, arguments=arguments):
+            return Apply(
+                target=recur(target),
+                arguments=recur_terms(arguments, recur),
+            )
+
+        case Immediate(value=_value):
+            return term
+
+        case Primitive(operator=operator, left=left, right=right):
+            match operator:
+                case "+":
+                    match recur(left), recur(right):
+                        case Immediate(value=i1), Immediate(value=i2):
+                            return Immediate(value=i1 + i2)
+
+                        case Immediate(value=0), right:
+                            return right
+
+                        case [
+                            Primitive(operator="+", left=Immediate(value=i1), right=left),
+                            Primitive(operator="+", left=Immediate(value=i2), right=right),
+                        ]:
+                            return Primitive(
+                                operator="+",
+                                left=Immediate(value=i1 + i2),
+                                right=Primitive(
+                                    operator="+",
+                                    left=left,
+                                    right=right,
+                                ),
+                            )
+
+                        case left, Immediate() as right:
+                            return _normalize_commutative_immediate_left("+", left, right)
+
+                        # Coverage reports a synthetic exit arc on this fallback match arm.
+                        # The arm is intentionally reachable and returns the non-folded primitive.
+                        case left, right:  # pragma: no branch
+                            return Primitive(
+                                operator="+",
+                                left=left,
+                                right=right,
+                            )
+
+                case "-":
+                    match recur(left), recur(right):
+                        case Immediate(value=i1), Immediate(value=i2):
+                            return Immediate(value=i1 - i2)
+
+                        # Coverage reports a synthetic exit arc on this fallback match arm.
+                        # The arm is intentionally reachable and returns the non-folded primitive.
+                        case left, right:  # pragma: no branch
+                            return Primitive(operator="-", left=left, right=right)
+
+                # Coverage may report an extra arc on this literal case label under pattern matching.
+                # Runtime terms validated by the syntax model still follow normal folding logic below.
+                case "*":  # pragma: no branch
+                    match recur(left), recur(right):
+                        case Immediate(value=i1), Immediate(value=i2):
+                            return Immediate(value=i1 * i2)
+
+                        case Immediate(value=0), _:
+                            return Immediate(value=0)
+
+                        case _, Immediate(value=0):
+                            return Immediate(value=0)
+
+                        case Immediate(value=1), right:
+                            return right
+
+                        case left, Immediate(value=1):
+                            return left
+
+                        case left, Immediate() as right:
+                            return _normalize_commutative_immediate_left("*", left, right)
+
+                        # Coverage reports a synthetic exit arc on this fallback match arm.
+                        # The arm is intentionally reachable and returns the non-folded primitive.
+                        case left, right:  # pragma: no branch
+                            return Primitive(operator="*", left=left, right=right)
+
+        case Branch(operator=operator, left=left, right=right, consequent=consequent, otherwise=otherwise):
+            folded_left = recur(left)
+            folded_right = recur(right)
+            folded_consequent = recur(consequent)
+            folded_otherwise = recur(otherwise)
+            match operator:
+                case "<":
+                    match folded_left, folded_right:
+                        case Immediate(value=i1), Immediate(value=i2):
+                            return folded_consequent if i1 < i2 else folded_otherwise
+                        case _:
+                            pass
+                # Coverage may report an extra arc on this literal case label under pattern matching.
+                # Runtime terms validated by the syntax model use only "<" and "==".
+                case "==":  # pragma: no branch
+                    match folded_left, folded_right:
+                        case Immediate(value=i1), Immediate(value=i2):
+                            return folded_consequent if i1 == i2 else folded_otherwise
+                        case _:
+                            pass
+            return Branch(
+                operator=operator,
+                left=folded_left,
+                right=folded_right,
+                consequent=folded_consequent,
+                otherwise=folded_otherwise,
+            )
+
+        case Allocate(count=count):
+            return Allocate(count=count)
+
+        case Load(base=base, index=index):
+            return Load(base=recur(base), index=index)
+
+        case Store(base=base, index=index, value=value):
+            return Store(base=recur(base), index=index, value=recur(value))
+
+        # Coverage may report an extra structural arc for this match arm.
+        # Semantically this always returns the reconstructed Begin node.
+        case Begin(effects=effects, value=value):  # pragma: no branch
+            return Begin(effects=recur_terms(effects, recur), value=recur(value))

packages/L2/src/L2/constant_propogation.py

@@ -0,0 +1,88 @@
+from functools import partial
+
+from .syntax import (
+    Abstract,
+    Allocate,
+    Apply,
+    Begin,
+    Branch,
+    Immediate,
+    Let,
+    Load,
+    Primitive,
+    Reference,
+    Store,
+    Term,
+)
+from .util import (
+    Context,
+    extend_context_with_bindings,
+    recur_terms,
+)
+
+
+def constant_propogation_term(
+    term: Term,
+    context: Context,
+) -> Term:
+    recur = partial(constant_propogation_term, context=context)
+
+    match term:
+        case Let(bindings=bindings, body=body):
+            new_bindings, new_context = extend_context_with_bindings(bindings, context, recur)
+            return Let(
+                bindings=new_bindings,
+                body=constant_propogation_term(body, new_context),
+            )
+
+        case Reference(name=name):
+            if name in context:
+                return context[name]
+            return term
+
+        case Abstract(parameters=parameters, body=body):
+            abstract_context = {name: value for name, value in context.items() if name not in parameters}
+            return Abstract(
+                parameters=parameters,
+                body=constant_propogation_term(body, abstract_context),
+            )
+
+        case Apply(target=target, arguments=arguments):
+            return Apply(
+                target=recur(target),
+                arguments=recur_terms(arguments, recur),
+            )
+
+        case Immediate(value=_value):
+            return term
+
+        case Primitive(operator=operator, left=left, right=right):
+            return Primitive(
+                operator=operator,
+                left=recur(left),
+                right=recur(right),
+            )
+
+        case Branch(operator=operator, left=left, right=right, consequent=consequent, otherwise=otherwise):
+            return Branch(
+                operator=operator,
+                left=recur(left),
+                right=recur(right),
+                consequent=recur(consequent),
+                otherwise=recur(otherwise),
+            )
+
+        case Allocate(count=count):
+            return Allocate(count=count)
+
+        case Load(base=base, index=index):
+            return Load(base=recur(base), index=index)
+
+        case Store(base=base, index=index, value=value):
+            return Store(base=recur(base), index=index, value=recur(value))
+
+        case Begin(effects=effects, value=value):  # pragma: no branch
+            return Begin(
+                effects=recur_terms(effects, recur),
+                value=recur(value),
+            )