Should have fixed O1OA issues

1. Cleaned up lots of scripts to autoamte
2. Fixed EIPs
3. Confirmed should work for Coco, Visitor, Algebra

Author: heineman

Diff for: attic/M0Test.scala

@@ -0,0 +1,18 @@
+package mathdomain
+
+class M0Test() extends org.scalatest.funsuite.AnyFunSuite {
+
+  this.test("Test")(
+    {
+      assert (new mathdomain.m0.Add(new mathdomain.m0.Lit(1.0),new mathdomain.m0.Lit(2.0)).accept[Double](this.makeEval) == 3.0);
+      assert (new mathdomain.m0.Lit(5.0).accept[Double](this.makeEval) == 5.0);
+    }
+  );
+
+  // this was this.test("makeEval") and that is wrong
+  def makeEval()
+    {
+    return new mathdomain.m0.Eval()
+    }
+
+}

Diff for: build.sbt

@@ -83,7 +83,7 @@ lazy val languageJava =
   standardLanguageProject("java")
     .settings(libraryDependencies += "com.github.javaparser" % "javaparser-core" % "3.19.0")
     .settings(
-      Compile/run/mainClass := Some("org.combinators.ep.language.java.systemJ.DirectToDiskMainJ")
+      Compile/run/mainClass := Some("org.combinators.ep.language.java.DirectToDiskMain")
      )
 
 lazy val helloWorldProject: Project =
@@ -92,7 +92,7 @@ lazy val helloWorldProject: Project =
     .settings(
       moduleName := s"expression-problem-language-helloworld",
     )
-    .dependsOn(core, languageJava)
+    .dependsOn(core, languageJava, languageNewScala)
 
 lazy val exitSBT =
   standardLanguageProject("java")

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala

@@ -873,12 +873,9 @@ trait ObjectAlgebras extends ApproachImplementationProvider {
     ) {
       return domain
     }
-    if (orderedImplementers.isEmpty) {
-      println(op + "," + domain.name)
-    }
     orderedImplementers.head
 
-
+// LEAVE THIS HERE TO SHOW WHAT WAS REPLACED
 //    // find type case where domainSpecific says you are implemented here.
 //    val result = domain.flatten.typeCases.map(tpeCase =>
 //      // are we implementing or overriding.

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala

@@ -1,5 +1,6 @@
 package org.combinators.ep.approach.oo    /*DI:LI:AD*/
 
+import org.combinators.ep.domain.GenericModel
 import org.combinators.ep.domain.abstractions.{DataType, DataTypeCase, Operation, Parameter}
 import org.combinators.ep.generator.Command.Generator
 import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach
@@ -21,6 +22,7 @@ trait OperationAsClass extends ApproachImplementationProvider {
                           tpe: DataType,
                           tpeCase: DataTypeCase,
                           op: Operation,
+                          model: GenericModel,
                           domainSpecific: EvolutionImplementationProvider[this.type]
                         ): Generator[MethodBodyContext, Option[Expression]]
 
@@ -86,7 +88,7 @@ trait OperationAsClass extends ApproachImplementationProvider {
    * @return
    * @see  makeImplementation
    */
-  def operationClass(methodName:Name, op:Operation, typeCases:Seq[DataTypeCase], base:DataType, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = {
+  def operationClass(methodName:Name, op:Operation, model:GenericModel, typeCases:Seq[DataTypeCase], base:DataType, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = {
     import ooParadigm.classCapabilities._
 
     for {
@@ -95,7 +97,7 @@ trait OperationAsClass extends ApproachImplementationProvider {
       _ <- addParamFields(op)
       _ <- addConstructor(makeOperationConstructor(op))
       _ <- forEach (typeCases) { tpe =>
-        addMethod(methodName, makeImplementation(base, tpe, op, domainSpecific))
+        addMethod(methodName, makeImplementation(base, tpe, op, model, domainSpecific))
       }
     } yield ()
   }

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/RuntimeDispatch.scala

@@ -199,7 +199,7 @@ trait RuntimeDispatch extends SharedOO with OperationAsClass {
     import ooParadigm.classCapabilities._
 
     for {
-      _ <- operationClass(names.addPrefix("_", names.mangle(names.instanceNameOf(op))), op, domain.typeCases, domain.baseDataType, domainSpecific)
+      _ <- operationClass(names.addPrefix("_", names.mangle(names.instanceNameOf(op))), op, domain, domain.typeCases, domain.baseDataType, domainSpecific)
 
       returnTpe <- toTargetLanguageType(op.returnType)
       _ <- resolveAndAddImport(returnTpe)
@@ -273,6 +273,7 @@ trait RuntimeDispatch extends SharedOO with OperationAsClass {
   override def makeImplementation(tpe: DataType,
                                   tpeCase: DataTypeCase,
                                   op: Operation,
+                                  model: GenericModel,
                                   domainSpecific: EvolutionImplementationProvider[this.type]
                                  ): Generator[MethodBodyContext, Option[Expression]] = {
     import paradigm.methodBodyCapabilities._

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/SharedOO.scala

@@ -114,6 +114,7 @@ trait SharedOO extends ApproachImplementationProvider {
                           tpe: DataType,
                           tpeCase: DataTypeCase,
                           op: Operation,
+                          model: GenericModel,
                           domainSpecific: EvolutionImplementationProvider[this.type]
                         ): Generator[MethodBodyContext, Option[Expression]] = {
     import paradigm.methodBodyCapabilities._
@@ -134,7 +135,8 @@ trait SharedOO extends ApproachImplementationProvider {
             tpeCase,
             thisRef,
             atts,
-            Request(op, args)
+            Request(op, args),
+            Some(model)
           )
         )
     } yield result

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/Traditional.scala

@@ -42,7 +42,7 @@ trait Traditional extends SharedOO {  // this had been sealed. not sure why
    * A constructor is generated, using [[makeConstructor]]. Fields are generates, using [[makeField]]. Each
    * operation is embedded as a method within each class, using [[makeImplementation]]
    */
-  def makeDerived(tpe: DataType, tpeCase: DataTypeCase, ops: Seq[Operation], domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = {
+  def makeDerived(tpe: DataType, tpeCase: DataTypeCase, ops: Seq[Operation], domain:GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ProjectContext, Unit] = {
     import ooParadigm.projectCapabilities._
     val makeClass: Generator[ClassContext, Unit] = {
       import classCapabilities._
@@ -53,7 +53,7 @@ trait Traditional extends SharedOO {  // this had been sealed. not sure why
         _ <- forEach (tpeCase.attributes) { att => makeField(att) }
         _ <- addConstructor(makeConstructor(tpeCase))
         _ <- forEach (ops) { op =>
-            addMethod(names.mangle(names.instanceNameOf(op)), makeImplementation(tpe, tpeCase, op, domainSpecific))
+            addMethod(names.mangle(names.instanceNameOf(op)), makeImplementation(tpe, tpeCase, op, domain, domainSpecific))
           }
       } yield ()
     }
@@ -81,7 +81,7 @@ trait Traditional extends SharedOO {  // this had been sealed. not sure why
 
       _ <- makeBase(flatDomain.baseDataType, flatDomain.ops)
       _ <- forEach (flatDomain.typeCases.distinct) { tpeCase =>
-          makeDerived(flatDomain.baseDataType, tpeCase, flatDomain.ops, domainSpecific)
+          makeDerived(flatDomain.baseDataType, tpeCase, flatDomain.ops, gdomain, domainSpecific)
         }
     } yield ()
   }